输入的第一行是整数N，即Alice类中的子节点数。以下N行中的每一行都包含一个整数，表示每个孩子的评分。
在输出的唯一一行打印一个整数，描述Alice必须给出的最小糖果数。
3
1
2
2
4
爱丽丝必须提供的糖果数量为1,2和1。
N并且每个孩子的评分不超过10 ^ 5.
有人可以帮助我吗？
答案 0 :(得分：23)
你可以两次通过。从拥有一个糖果的每个人开始。
如果评级[i]＆gt;，则首先从1到n-1（基于零）循环i。等级[i-1]然后糖果[i] =糖果[i-1] +1
然后将i从n-2循环到0;如果评级[i]＆gt;评级[i + 1]然后糖果[i] =最大（糖果[i]，糖果[i + 1] +1）
这很容易显示这给你一个有效的糖果分布，因为第二个循环不会破坏第一个固定的任何东西，所有可能的评级差异必须由两个中的一个捕获循环。这将使用最少数量的糖果并不明显，但如果仔细检查每项任务，您可以证明条件证明每个步骤所需的糖果数量（由特定个人）的下限
答案 1 :(得分：13)
为了使这个算法的分析更有趣，我将提供以下输入：
9
2
3
4
4
4
2
1
3
4
首先，请注意，如果一个孩子坐在一个正在获得x糖果的孩子旁边，那个孩子的评分较低，那么第一个孩子应该至少得到x+1个糖果。差异超过1只会浪费糖果。差异有时必须大于1，但我会在以后发生这种情况。
现在找到那些只应该买一个糖果的孩子。我将评级视为一个山脉（评级越高，山峰越高）并找到应该得到一个糖果的孩子寻找山谷（两个邻居的评分更高或相同的评分< / strong>）在山脉中。给出的示例看起来像（箭头用箭头表示）：
*** *
**** **
****** **
*********
^ ^ ^
为了这个过程的目的，我假设在这条线的开始和结束之前有2个“无限”高度的峰值。 （当我说无限时，我只是意味着比输入中的任何可能值都大，所以你可以使用10^5+1作为“无穷大”。在实践中，我会使用一个大于那个问题设定者有错误的值输入数据。）
您可以使用以下代码轻松找到山谷：
ratings = ...
N = ...
valleys = []
def get_rating(i):
if i < 0 or i > N-1:
return INFINITY
return ratings[i]
for i from 0 to N-1:
if get_rating(i) <= get_rating(i-1) and get_rating(i) <= get_rating(i+1):
valleys.append(i)
数组valleys包含山谷的索引。我们知道代表山谷的每个孩子应该得到一个糖果。为了说明，假设山谷在索引4处。现在我们知道指数3和5的孩子应该至少获得2个糖果。如果指数2的孩子的评分高于指数3的孩子那么孩子应该得到至少3个糖果。等等为2和向下。同样适用于6岁及以上。
注意我说“至少”，这是因为峰值（孩子的等级高于他们的邻居的两个，注意不同于山谷，我在这个定义中不包括相等）。峰值可以有两个最小约束条件，我们只选择两者中较大的一个。
现在我们可以通过以下代码找到每个孩子应该得到的糖果数量：
candies = [0] * N # An array of N 0s
for valley_idx in valleys:
candies[valley_idx] = 1
cur_idx = valley_idx-1
cur_candies = 2
while cur_idx >= 0 and ratings[cur_idx] > ratings[cur_idx+1]:
candies[cur_idx] = max(candies[cur_idx], cur_candies)
cur_idx -= 1
cur_candies += 1
cur_idx = valley_idx+1
cur_candies = 2
while cur_idx < N and ratings[cur_idx] > ratings[cur_idx-1]:
candies[cur_idx] = max(candies[cur_idx], cur_candies)
cur_idx += 1
cur_candies += 1
然后教师需要购买的糖果数量是candies数组中值的总和。
对于我们的示例输入或图表形式，答案结果为18：
* * *
** ** **
*********
在上面的解决方案中，我假设相同评级的相邻孩子不会对糖果的数量施加任何限制。如果情况是两个孩子都需要获得相同数量的糖果，我们可以很容易地改变算法以考虑到这一点。
基本思想是我们进行一种运行长度编码，因为我们可以注意到连续有一个或多个孩子具有相同的评级它不会改变他们的邻居应该获得的糖果数量。我们需要连续跟踪孩子的数量，因为连续5个孩子得到5个糖果意味着我们必须发出25个糖果而不仅仅是5个。我们用multipliers数组来做这个。使用以下代码，我们找到新的ratings数组和multipliers数组：
new_ratings = [ratings[0]]
multipliers = [1]
for i from 1 to N-1:
if ratings[i] == new_ratings[len(new_ratings)-1]:
multipliers[len(new_ratings)-1] += 1
else:
new_ratings.append(ratings[i])
multipliers.append(1)
现在我们只在new_ratings数组上运行原始算法并获得candies数组。然后获得我们可以运行的实际糖果数量：
answer = 0
for i from 0 to len(new_ratings)-1:
answer += multipliers[i] * candies[i]
对于我们的示例输入或图表形式，答案结果为20：
*** *
***** **
*********
答案 2 :(得分：8)
我使用简单的DP方法来解决这个问题。如果你的评级大于前一个，则增加DP表中的第i个值，否则可能有两个条件。一个条件是先前索引的DP值为1然后以相反的顺序遍历，直到您获得小于其下一个值的值并继续更新DP。另一个条件是先前索引的DP值大于1，在那种情况下，DP中的当前索引被指定为1.
for(int i=1; i <= n; i++){
scanf("%d", ra+i);
if( ra[i] > ra[i-1] )
dp[i] = dp[i-1] + 1;
else if( dp[i-1] == 1 ){
dp[i] = 1;
for( int j=i-1; j>0; j-- )
if( ra[j] > ra[j+1] )
dp[j] = max ( dp[j+1] + 1, dp[j] );
else
break;
}
else
dp[i] = 1;
}
long long sum = 0;
for(int i = 1;i <= n; i++)sum+= dp[i];
printf("%lld\n",sum);
答案 3 :(得分：6)
实际上这个问题可以通过在数组上传递两次来解决。并且解决方案将是O（N）时间。 我通过使用geeksforgeeks陷阱雨水（http://www.geeksforgeeks.org/trapping-rain-water/）问题解决了这个问题。 同样的原则可以适用于这个问题。
首先，我们有两个规则。 - 每个学生至少获得1个糖果。 - 每个学生的评分都比他/她的邻居（下一个或前一个学生）更好，他将获得至少一个糖果。
正如我所说，我们需要两个传递数组。 第一个是从左到右; - 首先，我们将为第一个分配一个糖果。 - 然后通过检查当前的一个是否具有更高的评级来循环数组，然后给他一个比前一个学生多一个，否则给他1个糖果。
第二遍将是从右到左。 - 这次我们开始为最后一个分配一个糖果。 - 然后从右到左遍历数组，并在第一个循环中执行类似的操作。
在这两个循环之后，我们将通过获取数组的最大值来左右循环，并将此值添加到总糖果中。
Test cases :
input : { 1, 2, 2 }
output : { 1, 2, 1 } => 4
input : { 9, 2, 3, 4, 4, 4, 2, 1, 3, 4 }
output : { 2, 1, 2, 3, 1, 3, 2, 1, 2, 3 } => 20
您可以在下面找到针对此问题的Java解决方案。
public int calculate(int[] arr) {
int m = arr.length;
int[] left = new int[m];
int[] right = new int[m];
int candies = 0;
left[0] = 1;
for (int i = 1; i < m; i++)
left[i] = arr[i] > arr[i - 1] ? left[i - 1] + 1 : 1;
right[m - 1] = 1;
for (int i = m - 2; i >= 0; i--)
right[i] = arr[i] > arr[i + 1] ? right[i + 1] + 1 : 1;
for (int i = 0; i < m; i++)
candies += Math.max(left[i], right[i]);
return candies;
}
public int calculate(int[] arr) {
int m = arr.length;
int[] left = new int[m];
int[] right = new int[m];
int candies = 0;
left[0] = 1;
for (int i = 1; i < m; i++)
left[i] = arr[i] > arr[i - 1] ? left[i - 1] + 1 : 1;
right[m - 1] = 1;
for (int i = m - 2; i >= 0; i--)
right[i] = arr[i] > arr[i + 1] ? right[i + 1] + 1 : 1;
for (int i = 0; i < m; i++)
candies += Math.max(left[i], right[i]);
return candies;
}
答案 4 :(得分：4)
我们说
1,5,2,10,10 3,8,9,1,1,2作为11名学生S1至S11的评分
让我们说我们对学生进行图表评级，其中评分在y轴上绘制，然后
本地最小值总是会得到一个糖果，所以学生S1，S3，S6，S9和S10将是本地最小值并且会获得一个糖果。我们可以说，有一个最小的解决方案（So）偏离我们的说法，那么我们可以创建一个更多的解决方案（So1），其中所有学生得到相同的糖果和偏离的局部最小值获得一个糖果，然后So1将是因此，当地最小的糖果超过1时，就没有最低限度的解决方案。
一旦你得到了当地最小值的值，你可以横向最小值左右来计算其他学生的糖果。
对于局部最大值，它的相邻节点+1的值将更大。工作代码如下，时间复杂度为O（n），空间复杂度为O（n）
public static int candy(ArrayList<Integer> a) {
int size = a.size();
int[] cand = new int[size];
// give all children candies equal to 1
// local minimas will get 1
for(int i = 0; i < size; i++)
{
cand[i] = 1;
}
// increase count on the right of local minimas
for(int i = 1; i < size; i++)
{
if(a.get(i) > a.get(i-1))
{
cand[i] = cand[i-1]+1;
}
}
// increase count on the left of local minimas
// local maximas should be max of left and right
for(int i = size-2; i >= 0; i--)
{
if(a.get(i) > a.get(i+1))
{
cand[i] = Math.max(cand[i], cand[i+1]+1);
}
}
// get the sum
int count = 0;
for(int i = 0; i < size; i++)
{
count = count + cand[i];
}
return count;
}
您可以使用测试用例进行测试 HackerEarth问题：https://www.hackerrank.com/challenges/candies
Leetcode：https://leetcode.com/problems/candy/
找到更详细的解释答案 5 :(得分：2)
非常简单的实施
空间复杂度：O（n） 时间复杂度：O（n）
步骤1：从左到右开始遍历数组，并将值1分配给dp数组中的每个索引。
步骤2：从左到右开始遍历阵列，如果该人得分更多，那么坐在他左边的那个人的dp将是dp [i-1] +1;
步骤3：从右到左开始遍历阵列，如果该人得分更多，那么坐在他右边的那个人的dp将是max（dp [i]，dp [i + 1] +1 ）;
步骤4：在dp数组中添加所有值。
#include<bits/stdc++.h>
using namespace std;
long int arr[100005];
long int dp[100005];
int main()
{
int n,i;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%ld",&arr[i]);
long int ans=0;
dp[0]=1;
for(i=1;i<n;i++)
{
if(arr[i]>arr[i-1])
dp[i]=dp[i-1]+1;
else
dp[i]=1;
}
for(i=n-2;i>=0;i--)
{
if(arr[i]>arr[i+1])
dp[i]=max(dp[i],dp[i+1]+1);
}
for(i=0;i<n;i++)
{
ans=ans+dp[i];
}
cout<<ans<<endl;
return 0;
}
答案 6 :(得分：1)
我觉得这可能是可能的解决方案之一...
def candy(N,r):
H=[0]*N
R=r
cur_can=1
cand=[0]*N
cand[0]=1
#print R#,'\n',cand
for i in range(0,N):
if i!=0:
#print R[i],' ',R[i-1]
if R[i]>R[i-1]:
cand[i]=cand[i-1]+1
else:
cand[i]=1
## print R[i],i
sum=0
## print i
print cand
for j in range(0,N):
sum+=cand[j]
return sum
r=[1,2,2,4,1,2,4]
N=len(r)
print candy(N,r)
在代码中用作样本的值的输出得出12作为答案，这似乎对我来说...... 你觉得怎么样？
答案 7 :(得分：1)
我不认为这是一个非常棘手的问题。如果你仔细想想，你会得到自己的答案。
#include <iostream>
#include <queue>
using namespace std;
#define CALC(n) (n)+(n)*((n)-1)/2
struct PAIR {
int n;int up;//up=0,1,2; 0是升，1是平，2是降
public:
PAIR(int _n,int _u){
n=_n;up=_u;
}
};
int N;
queue<PAIR> q;
int calc(int up,int p){
if(up==1)
return p;
else {
return p+p*(p-1)/2;
}
}
int getType(int lc,int c){
int up=-1;
if(c>lc)
up=0;
else if(c==lc)
up=1;
else
up=2;
return up;
}
int main(int argc, const char * argv[])
{
scanf("%d",&N);
int lastChild,child,n=2;
long long result=0;
scanf("%d%d",&lastChild,&child);N-=2;
int up=getType(lastChild, child);
lastChild=child;
while (N--) {
scanf("%d",&child);
int tu=getType(lastChild, child);
if(tu==up)
n++;
else {
q.push(PAIR(n,up));
n=2;
up=tu;
}
lastChild=child;
}
q.push(PAIR(n,up));
q.push(PAIR(1,1));
/*其实主要就是看转折点是属于上一段还是当前段。
如果是正V的话，转折点属于后一段。前一段的和-1.
如果是倒V的话，转折点属于长的一段。
然后是平的和别的有搭配的话，转折点属于别的
*/
PAIR lastp=q.front();q.pop();
while(q.size()){
PAIR pir=q.front();q.pop();
if(pir.up==1){
result+=calc(lastp.up,lastp.n);//如果下一段是平的，就把转折点分到上一段
pir.n-=1;
}
else if(lastp.up==1){
result+=calc(lastp.up,lastp.n-1);//如果上一段是平的，就把转折点分到下一段
} else if((lastp.up==0)&&(pir.up==2)){//如果是倒V型的，转折点属于长的
if(lastp.n>pir.n){
result+=calc(lastp.up,lastp.n);
pir.n-=1;
} else {
result+=calc(lastp.up,lastp.n-1);
}
} else if((lastp.up==2)&&(pir.up==0)){//如果是正V型的，转折点属于后一个
result+=calc(lastp.up,lastp.n)-1;
} else {
printf("WRONG!");
}
lastp=pir;
}
printf("%lld\n",result);
return 0;
}
答案 8 :(得分：1)
我使用两个队列来存储增加和减少的未分配索引序列，并列举相邻评级的所有可能情况，并在评级达到平台或底部时（即当前评级是局部最小值或与之前相同时）分配糖果。
这是我的解决方案：
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <deque>
void assigncandies(std::deque<int>& incr, std::deque<int>& decr, unsigned int& total) {
int incrlen = incr.size();
int decrlen = decr.size();
if (incrlen >= decrlen) {
int num=incrlen;
int last = incr.back();
while(!incr.empty()) {
int idx = incr.back();
total += num;
incr.pop_back();
num --;
}
if (!decr.empty()) {
if (last == decr.front()) decr.pop_front();
num=1;
while(!decr.empty()) {
int idx = decr.back();
//candies[idx]=num;
total += num;
decr.pop_back();
num ++;
}
}
} else {
int num=decrlen;
int last = decr.front();
while (!decr.empty()) {
int idx = decr.front();
//candies[idx]=num;
total += num;
decr.pop_front();
num --;
}
if (!incr.empty()) {
if (last == incr.back()) incr.pop_back();
num=1;
while(!incr.empty()) {
int idx = incr.front();
//candies[idx]=num;
total += num;
incr.pop_front();
num ++;
}
}
}
}
int main () {
int N;
unsigned int total=0;
int PrevR, CurR, NextR;
std::cin >> N;
std::deque<int> incr;
std::deque<int> decr;
for (int i = 0; i<N;i++) {
if (i==0) {
std::cin>>CurR;
std::cin >> NextR;
} else if (i != N-1) std::cin >> NextR;
if (i==0) {
if (CurR>NextR) decr.push_back(0);
else if (CurR<NextR) incr.push_back(0);
else total=1;
} else if (i==N-1) {
if (PrevR<CurR) {
incr.push_back(i);
}
if (PrevR>CurR) {
decr.push_back(i);
}
if (PrevR==CurR) {
total += 1;
}
assigncandies(incr,decr,total);
} else {
if (PrevR == CurR && CurR == NextR) {
assigncandies(incr,decr,total);
total += 1;
}
if (PrevR == CurR && CurR < NextR) {
assigncandies(incr,decr,total);
incr.push_back(i);
}
if (PrevR == CurR && CurR > NextR) {
assigncandies(incr,decr,total);
decr.push_back(i);
}
if (PrevR < CurR) {
incr.push_back(i);
if (CurR > NextR) decr.push_back(i);
}
if (PrevR > CurR && CurR >= NextR) {
decr.push_back(i);
}
if (PrevR > CurR && CurR < NextR) {
decr.push_back(i);
assigncandies(incr,decr,total);
total -= 1;
incr.push_back(i);
}
}
PrevR = CurR;
CurR = NextR;
}
std::cout<<total<<std::endl;
return 0;
}
它通过了测试用例和正确的3/10个案例，但我得到了其余的分段错误
我想知道是否有人能指出我的代码有什么问题
非常感谢你！
答案 9 :(得分：1)
也许是最简单的解决方案：
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int children;
int sum=0;
cin >> children;
int ratings[children];
int candies[children];
//give all children 1 candy to start
for(int i=0;i<children;++i)
{
cin >> ratings[i];
candies[i] = 1;
}
//if the current child has a better rating than the child
//before him he is entitled to +1 greater candy than that child
for(int i=1;i<children;++i)
{
if(ratings[i] > ratings[i-1])
candies[i] = candies[i-1]+1;
}
// work backwards to break any discrepancies ex.
// rating[5,4,3] -> candies[1,1,1] -> candies [1,1,1] -> candies [3,2,1]
// starting ratings give everyone 1 first loop second loop
for(int i=children-1;i>=0;--i)
{
if(ratings[i] > ratings[i+1])
{
candies[i] = max(candies[i],candies[i+1]+1);
}
}
for(int i=0;i<children;++i)
{
sum+=candies[i];
}
cout << sum;
return 0;
}
答案 10 :(得分：0)
1.使用给定的评级初始化Ratings[]。
2.我们首先给每个孩子1 Candy。因此，使用1初始化Val[]中的所有成员。
3.现在遍历并检查2个相邻的孩子（i + 1和i - 1）是否符合条件。
4.保持这样做，直到我们得到一个完整的遍历，条件永远不会被打破。我们当时就完成了！
bool done = false;
while (!done)
{
done = true;
for (int i = 0 to i = Ratings.size() - 1)
{
for (int k = 1 and k = -1)
{
int adjacent = i + k;
if (adjacent >= 0 && adjacent < N)
{
if (Ratings[adjacent] > Ratings[i] && Val[adjacent] <= Val[i])
{
Val[adjacent] = Val[i] + 1;
done = false;
}
}
}
}
}
答案 11 :(得分：0)
# this python code solves the problem for all test cases on interviewstreet
#!/usr/bin/python
if __name__ == "__main__":
N = int(raw_input().strip())
scores = []
for i in range(N):
scores.append(int(raw_input().strip()))
nc = []
if(scores[0]>scores[1]):
nc.append(-1)
else:
nc.append(0)
for i in range(1,N-1):
if (scores[i] > scores[i-1]) and (scores[i]>scores[i+1]):
nc.append(2)
elif (scores[i] > scores[i-1]):
nc.append(1)
elif (scores[i]>scores[i+1]):
nc.append(-1)
else:
nc.append(0)
if(scores[N-1]> scores[N-2]):
nc.append(1)
else:
nc.append(0)
noc = []
for i in range(N):
noc.append(0)
for i in range(N):
if(nc[i]==0):
noc[i] = 1
for i in range(N):
if(nc[i]==1) and (noc[i-1]!=0):
noc[i] = noc[i-1]+1
for i in range(N-1,-1,-1):
if(nc[i]==-1) and (noc[i+1]!=0):
noc[i] = noc[i+1]+1
for i in range(N):
if(nc[i]==2) and (noc[i-1]!=0) and (noc[i+1]!=0):
noc[i] = max((noc[i-1],noc[i+1]))+1
nt = sum(noc)
print nt
答案 12 :(得分：0)
考虑这些可能的评级配置： 1 2 3 4 5或任何增加的顺序 和 5 4 3 2 1或任何递减序列
在第一种情况下可以做些什么？ 1 2 3 4 5是分配的糖果 在第二种情况下，糖果是5 4 3 2 1
可以通过从左到右扫描阵列并从右到左识别增加和扫描的间隔并再次识别增加的间隔来获得解决方案。在这个过程中分配最少量的糖果。有关具体细节，请查看代码：
#include <stdio.h>
#include <algorithm>
using namespace std;
#define N 100000
int c[N];
int val[N];
int solve(int n)
{
int res=n;
int i=0,value=0;
while(i<n)
{
value=0;
i+=1;
while(i<n && c[i]>c[i-1])
{
value+=1;
val[i]=value;
i+=1;
}
}
i=n-1;
while(i>=0)
{
value=0;
i-=1;
while(i>=0 && c[i]>c[i+1])
{
value+=1;
val[i]=max(val[i],value);
i-=1;
}
}
for(i=0;i<n;++i) res+=val[i];
return res;
}
int main()
{
int n,i;
scanf("%d",&n);
for(i=0;i<n;++i) scanf("%d",&c[i]);
printf("%d\n",solve(n));
return 0;
}
答案 13 :(得分：0)
总结：
#include <vector>
#include <iostream>
using namespace std;
int main() {
int N;
cin>>N;
vector<int> A(N,0),B(N,1);
for(int i=0;i<N;++i) cin>>A[i];
for(int i=0;i<N;++i) if(A[i]>A[i-1]) B[i]=B[i-1]+1;
for(int j=N-2;j>=0;--j) if (A[j]>A[j+1]) B[j] = max(B[j], B[j+1]+1);
int sum=0;
for(int i=0;i<N;++i) sum+=B[i];
cout<<sum<<endl;
return 0;
}
答案 14 :(得分：0)
使用Java语言将数组作为输入的简单工作代码。 时间复杂度：O（n）。
import java.util.Arrays;
public class MyClass {
public static void main(String[] args) {
int []childrenRating = {9, 8, 7, 10, 11, 12, 14, 1, 5};
int []expectedDistribution = {3, 2, 1, 2, 3, 4, 5, 1, 2};
int []resultingDistribution = new int[childrenRating.length];
int v = 1;
int k, j = 0;
while(j < childrenRating.length){
k = j;
if(k >0 && childrenRating[k] == childrenRating[k-1]) { v=1; }
resultingDistribution[k] = v;
while(j+1 < childrenRating.length && childrenRating[j+1] < childrenRating[j]){
j++;
}
v = 1;
for(int i = j; i > k; i--){
resultingDistribution[i] = v++;
}
resultingDistribution[k] = Math.max(resultingDistribution[k], v);
j++;
v = resultingDistribution[j-1]+1;
}
if(Arrays.equals(expectedDistribution, resultingDistribution)) {
System.out.println("Correct Distribution");
}
else {
System.out.println("Wrong Distribution!");
}
}
}
答案 15 :(得分：0)
AS mentioned by others,scanning left to right and then right to left,and getting max candies used at certain postion is working.
Before this, i used other way,which seemed to be working and i checked it with many different inputs,although i couldnt clearly write it in code,Here is the Algo:
Algorithm:
1.Use an int[]index array and store all the indexes in the sorted value of thie ranks.
so here
int values[]=9 2 3 6 5 4 3 2 2 2
so index sorted array would be
int index[]= 1 7 8 9 2 6 5 4 3 0
now int[] result=new result[10];
and initialize it with -1.
sending each value from index[]in the order and make sure that each one is satifying the given condtions.
that
i=index;
while(i>=0)
{
if(i-1>=0 && arr[i]>arr[i-1])
break;
if(i-1>=0 && arr[i]<arr[i-1])
result[i-1]=result[i]+1;
else
if(i-1>=0 && arr[i]==arr[i-1])
result[i-1]=1
i--;
}
//similary towards the right
i=index;
while(i<arr.length)
{
if(i+1<arr.length && arr[i]>arr[i+1])
break;
if(i+1<arr.length && arr[i]<arr[i+1])
result[i+1]=1+result[i];
else
if(i+1<arr.length && arr[i]==arr[i+1])
result[i+1]=1
i++;
}
so result array will be like this for index 1
2 1 2 3 - - - - - -
then for index 7
2 1 2 5(its modifed from 3) 4 3 2 1 1
followe by indeices :8 9 2 6 5 4 3 0
which all satifies the condtion and more modification occurs in this case..so total number of candies =22