糖果谜题

	利用哈希表做，记录相同数字长度，



	当长度大于数字值的时候，累计值加一的值，并更新该值的长度



	当值小于长度，累计值加一



	



	#include<iostream>



	#include<unordered_map>



	#include<vector>



	usingnamespacestd;



	intmain()



	{



	    inttemp;



	    unordered_map<int,int> m;



	    while(cin>>temp)



	    {



	        m[temp]++;



	    }



	    intres = 0;



	    for(auto iter = m.begin();iter!=m.end();iter++)



	    {



	        intval = iter->first;



	        intnum = iter->second;



	        while(num>val)



	        {



	            res += val+1;



	            num = num - val -1;



	        }



	            if(num == 0)



	                continue;



	            else



	            res += (val+1);



	    }



	    cout<<res<<endl;



	     



	}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

//总结目前牛客问题 第一,没有循环输入问题, 第二 有循环输入问题, 第三 输入有多余空格问题 ,第四 中间插入多余空行问题 ....
namespace Test0001
{
    class Program
    {
        public static void Main(string[] args)
        {
            //string line;
            //while (!string.IsNullOrEmpty(line = Console.ReadLine())) Func(line);
            Func(Console.ReadLine());
        }
        public static void Func(string line)
        {
            var s1 = line.Trim().Split(' ').Select(x => int.Parse(x)).GroupBy(x => x).Select(x => new { val = x.Key, count = x.Count() }).ToArray();
            int sum = 0;
            foreach (var item in s1)
            {
                int n = (item.count + item.val) / (item.val + 1);
                sum += (item.val + 1) * n;
            }
            Console.WriteLine(sum);
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;


public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] line1 = bf.readLine().split(" ");
        int n = line1.length;
        //记录相同回答的人的个数
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            int a = Integer.parseInt(line1[i]);
            map.put(a, map.getOrDefault(a, 0) + 1);
        }
        int sum = 0;
        /**
         * 解释一下：map = < a , 1 >，则这里至少有 a + 1 个小朋友
         *         map = < a , count>,当count大于1时候
         *         假如 a = 5,count = 4, 则至少有 5 + 1 个人，这四个人都拿同样的颜色，另外还有两个人个人也拿一样
         *         假如 a = 5,count = 5, 则至少有 5 + 1 个人，这五个人都拿同样的颜色，另外还有一个人也拿一样
         *         假如 a = 5,count = 6, 则至少有 5 + 1 个人，这六个人都拿同样的颜色，不存在另一个人
         *         假如 a = 5,count = 7, 则至少有 (5 + 1)*2 个人
         *         七个人中,6个人拿一样，剩下一个人肯定不能拿一样颜色了，那么最后一个人是单独的 即和< a,1> 一样的道理
         *         你把7个人分成两组，其实答案也是一样的，需要  (a+1)*2
         * 综上分析：
         *          每 a+1个人包括 a+1，都是 a+1个人
         *          可以理解为 7/6 余 1,需要 2倍的 a + 1
         *          直接 (count + a)/(a+1)就相当于向上取整了
         */
        for (Integer a : map.keySet()) {
            sum += ((map.get(a) + a) / (a + 1)) * (a + 1);
        }
        System.out.println(sum);
    }
}

21行代码

#include<stdio.h>
#include<unordered_map>
using namespace std;
int main(){
    unordered_map<int,int> mp;
    int t,sum=0,k;
    while(~scanf("%d",&t)){
        mp[t]++;
    }
    for(auto q:mp){
        if(q.first<q.second-1){
            k=q.first+1;
            while(k<q.second){
                k+=q.first+1;
            }
            sum+=k;
        }
        else sum+=q.first+1;
    }
    printf("%d",sum);
}

import math
v=list(map(int,input().split()))
v.sort()
count=0
i=0
while i <len(v):
    n=v.count(v[i])
    count=count+math.ceil(n/(v[i]+1))*((v[i]+1))
    i=i+n
print(count)

不是很复杂吧。。。

#include<bits/stdc++.h>
using namespace std;

const int MAXN = 1e3+1;

int cnt[MAXN];
int main(){
    int n;
    int M=0,sum=0;
    while(cin>>n){
        cnt[n]++;
        M=max(n,M);
    }
    for(int i=0;i<=M;i++){
        int num=cnt[i]%(i+1)?cnt[i]/(i+1)+1:cnt[i]/(i+1);
        sum+=(i+1)*num;
    }
    cout<<sum<<endl;
    return 0;
}

from collections import defaultdict
a = defaultdict(int)
b = list(map(int,input().split()))
for i in b:
    a[i] += 1
res = []
for i,j in a.items():
    tmp = j//(i+1)
    if j%(i+1) != 0:
        tmp += 1
    res.append(tmp*(i+1))
print(sum(res))

#include <bits/stdc++.h>
using namespace std;

int main(){
    int x,s=0;
    vector<int> v;
    map<int,int> m;
    while(cin>>x)
        v.push_back(x);
    int n = v.size();
    for(int i=0;i<n;i++){
        if(m.find(v[i])==m.end()){
            m[v[i]] = 1;
            s += v[i]+1;
        }else if(m[v[i]]<=v[i])
            m[v[i]]++;
        else{
            m[v[i]] = 1;
            s += v[i]+1;           
        }
    }
    cout<<s<<endl;
    return 0;
}

代码写的有点丑…………
这道题还比较有趣，思路重点就是：
1.相同的合并直至达到对应人数。
2.不相同的独立对应一个人数。
3.相同的超出对应人数，则新对应一个人数。
#include<iostream>
#include<vector>
#include<utility>
#include<algorithm>
using namespace std;

int main()
{
    vector<int> input;
    int tmp;
    while(cin>>tmp)
    {
        input.push_back(tmp);
        if(cin.get()=='\n')
            break;
    }
    int n=input.size();
    int j;
        //辅助数组
    vector<pair<int,int> > aux(n);
    vector<int>::iterator it;
    //aux[0].first=input[0]+1;
    //aux[0].second=1;
    for(int i=0;i<n;i++)
    {
                //不相同
        if((it=find(input.begin(),input.begin()+i,input[i]))==(input.begin()+i))
        {
            aux[i].first=input[i]+1;
            aux[i].second=1;
        }
                //相同
        else{
            j=it-input.begin();
                        //相同的要找：最近的 
            while((it=find(it+1,input.begin()+i,input[i]))!=(input.begin()+i))
            {
                if(aux[it-input.begin()].first==input[i]+1)
                    j=it-input.begin();
            }
                        //人数未满
            if(aux[j].second<aux[j].first)
            {
                aux[j].second+=1;
            }
                        //人数已满
            else{
                aux[i].first=input[i]+1;
                aux[i].second=1;
            }
        }
    }
    int num=0;
    vector<pair<int,int> >::iterator it1=aux.begin();
    for(;it1<aux.end();it1++)
    {
        if(it1->first!=0)
            num+=it1->first;
    }
    cout<<num;
    
}

#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main() {
	vector<int> v1;
	string str;
	getline(cin,str);
	int num = 0;
	int max = 0;
	for (int i = 0; i <= str.size(); i++) {
		if (str[i] != ' ' && str[i] != NULL) {
			num = num * 10 + str[i] - '0';
			continue;
		}
		v1.push_back(num);
		max = max > num ? max : num;
		num = 0;
	}
	vector<int> v2(max + 1, 0);
	for (int i = 0; i < v1.size(); i++)
		v2[v1[i]]++;
	int total = 0;
	for (int i = 0; i < v2.size(); i++) {
		int t = v2[i] / (i + 1);
		if (v2[i] % (i + 1) != 0) {
			total += i + 1;
		}
		total += t*(i + 1);
	}
	cout << total << endl;
}

其中回答学生个数最多1000
每个学生回答的答案在[0,999]之间

"""
思路：看相同的数字a可以构成几个团块，每个团块的最多数量是a+1
1.哈希计算数字的个数
2.遍历哈希表，假设2的个数5，即：222 22；前3个2可以构成一个团，后面两个2可以构成一个团，
每个团最多2+1个小朋友，所以共有6个；团个数可用除法和求余的方法计算
3.累加每个数字计算得到最终结果
"""
import sys

nums = list(map(int, input().strip().split()))

hashlist = {}
for num in nums:
    hashlist[num] = hashlist.get(num, 0) + 1

res = 0
for key, val in hashlist.items():
    tmp = val // (key+1)
    res += tmp*(key + 1) if val % (key+1) == 0 else (tmp+1)*(key+1)
print(res)

思想就是用map记录每个相同数字num的次数count；
1、count<=num+1，则该num对应的人数为num+1;
2、count>num,则进行num+1，count -= num;之后再进行判断，因为每一个num对应的人数最多为num+1，所以要减去num重新判断。

#include <iostream>
#include <map>
#include <algorithm>

using namespace std;

int main()
{
    map<int, int>mp;
    int num;
    while(cin>>num) {
        if(mp.find(num) == mp.end()) {//没有则建立字典
            mp.insert(make_pair(num, 1));
        }
        else
            mp.find(num)->second += 1;
    }
    int res = 0;
    for(map<int,int>::iterator i=mp.begin(); i!=mp.end(); ) {
        if(i->first == 0) {//均不同则键对应的值就是人数
            res += i->second;
            ++i;
        }
        else {
            res += i->first+1;
            if(i->second <= i->first+1) ++i;
            else i->second -= (i->first + 1);
        }
    }
    cout<< res << endl;
}

#include <iostream>

using namespace std;

int main()
{
    int mp[1001] = {0};
    int num;
    //先统计输入有几个不同的值。
    while(cin>>num) {
        mp[num]++;
    }
    
    int res = mp[0];
    for(auto i=1; i<1001; ) {
        if(mp[i] != 0) {//寻找出现的值
            res += i+1;
            if(mp[i] <= i+1) ++i;
            else mp[i] -= (i+1);
        } else
            ++i;
    }
    cout<< res << endl;
}

//这道题非常适合使用map进行解答
#include<iostream>
#include<map>
//#include<algorithm>
 
using namespace std;
int main()
{
    map<int,int> child;
    int aa,num=0;
 
    while(cin>>aa)
    {
        if(child.find(aa)==child.end())
        {
            child[aa] = 1;
        }
        else
        {
            ++child[aa];
        }
    }
 
    int key,nv;
    for(map<int,int>::iterator iter(child.begin());iter!=child.end();++iter)
    {
        key=iter->first;
        nv=iter->second;
        num += (nv/(key+1))*(key+1) + ((nv%(key+1)==0)?0:(key+1));
 
    }
    cout<<num;
 
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
int main(){
int arr[1000] = {0};
int tmp;
int result = 0;
while(cin>>tmp){
    arr[tmp]++;//用这个数组记录，下标i的数组取值表示报数为i的人数
}
for(int i=0;i<1000;i++){
    if(arr[i] != 0){//只考虑有人数的i，即人数不为0的报数i
        if(arr[i] > i){//报数为i的人数如果大于i,那么
            if(arr[i]%(i+1) == 0)//如果报数为i的人数是i+1的倍数，就正好组成一种颜色                           
                result += arr[i];
            else//如果不是i+1的倍数，那么要考虑多一种颜色，就除以（i+1）得到的整数+1，相当于多放这么多种颜色需要的最少人数
                result += (arr[i]/(i+1)+1)*(i+1);
        }
        else
            result += i+1;//报数相同的人数小于i，就直接加上多放一种颜色的最少人数
        }
    }
    cout<<result;
    return 0;
}