分组统计

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <cmath>
#include <set>
#include <queue>
  
using namespace std;
map<int,int> mp[105];
int xl[105];
int main()
{
    int n;
    cin >> n;
    while(n--)
    {
        int m;
        cin >> m;
        set<int> st;
        for(int i = 0 ;i<m;i++)
        {
            cin >> xl[i];
            st.insert(xl[i]);
        }
        set<int> group;
        for(int i = 0 ;i<m;i++)
        {
            int x;
            cin >> x;
            mp[x][xl[i]]++;
            group.insert(x);
        }
        for(set<int>::iterator it = group.begin();it!=group.end();it++)
        {
            int x = *it;
            cout << x << "={";
                
            for(set<int>::iterator itt = st.begin();itt!=st.end();itt++)
            {
                int y = *itt;
                cout << y << "=" << mp[x][y] ;
                itt++;
                if(itt != st.end())
                cout << ",";
                itt--;
            }
            cout << "}" << endl;
            mp[x].clear();
        }
        
    }
}

import java.util.*;
import java.util.Map.Entry;

public class Main {

    public static void main(String[] args) throws Exception {
        
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        for (int i = 1; i <= m; i++) {
            // 红黑树结构的集合,可以去重, 而且可以升序排序
            TreeSet<Integer> ts1 = new TreeSet<>();
            TreeSet<Integer> ts2 = new TreeSet<>();
            int n = sc.nextInt();
            int[] a1 = new int[200];
            int[] a2 = new int[200];
            for (int j = 0; j < n; j++) {
                a1[j] = sc.nextInt();
                ts1.add(a1[j]);
            }
            for (int j = 0; j < n; j++) {
                a2[j] = sc.nextInt();
                ts2.add(a2[j]);
            }
            // 两层map,形成{1:{3:0, 8:0}, 2:{3:0, 8:0}}的结构
            // 后面再遍历一遍, 将其中的0修改为实际出现的次数
            // 以第二行的元素为key, value是第一行的所有元素,出现次数0
            TreeMap<Integer, TreeMap<Integer, Integer>> tm1 = new TreeMap<>();
            for (Integer e : ts2) {
                TreeMap<Integer, Integer> tm2 = new TreeMap<>();
                for (Integer ea : ts1) {
                    tm2.put(ea, 0); // 初始次数为0
                }
                tm1.put(e, tm2);
            }
            // 遍历n个元素, 修改其中第一行元素出现的次数
            for (int j = 0; j < n; j++) {
                TreeMap<Integer, Integer> tm2 = tm1.get(a2[j]);
                int t = tm2.get(a1[j]);
                tm2.put(a1[j], ++t);
                // tm1.put(a2[j], tm2); // 引用类型,不需要重新put一遍
            }
            // 因为treeMap,会自动由小到大排序的
            for (Entry<Integer, TreeMap<Integer, Integer>> e : tm1.entrySet()) {
                System.out.print(e.getKey() + "={");
                boolean f = true;//判断是否要加逗号
                for (Entry<Integer, Integer> ea : e.getValue().entrySet()) {
                    if (f) {
                        System.out.print(ea.getKey() + "=" + ea.getValue());
                        f = false;
                    }else {
                        System.out.print(","+ea.getKey() + "=" + ea.getValue());
                    }
                }
                System.out.println("}");
            }

        }

    }
}

//1.根据分组把相同组的数拿出来2.对一个组的数进行排序,去重的同时计算每个数的个数
#include<stdio.h>
int main()
{
    int m;
    scanf("%d",&m);
    while(m--)
    {
        int n,a[1000]={0},aa[1000]={0},bb[1000]={0},b[1000]={0},c[1000]={0},p,max=0,i,j,k,num;
        scanf("%d",&n);//输入
        for(i=0;i<n;i++)
            {scanf("%d",&a[i]);
            aa[i]=a[i];}
        for(i=0;i<n;i++)
        {
            scanf("%d",&b[i]);
            bb[i]=b[i];
            if(b[i]>max)
                max=b[i];//最大组
        }
        //对原数据排序去重
        int w=n;
        for(i=0;i<w-1;i++)
            for(j=0;j<w-1-i;j++)
            if(aa[j]>aa[j+1])
        {
            int t=aa[j];aa[j]=aa[j+1];aa[j+1]=t;
        }
        for(i=0;i<w;i++)
        {
            if(aa[i]==aa[i+1])
            {
                for(j=i;j<w;j++)
                    aa[j]=aa[j+1];
                i--;w--;
            }
        }

        //对原数据排序去重
        int w1=n;
        for(i=0;i<w1-1;i++)
            for(j=0;j<w1-1-i;j++)
            if(bb[j]>bb[j+1])
        {
            int t=bb[j];bb[j]=bb[j+1];bb[j+1]=t;
        }
        for(i=0;i<w1;i++)
        {
            if(bb[i]==bb[i+1])
            {
                for(j=i;j<w1;j++)
                    bb[j]=bb[j+1];
                i--;w1--;
            }
        }
        //分割每一组
        for(i=0;i<w1;i++)//每一组
        {
            num=0;
            for(j=0;j<n;j++)
            {
                if(bb[i]==b[j])//在同一组
                c[num++]=a[j];
            }
            //对比个数
            int count[100]={0};
            for(j=0;j<w;j++)
            {
                for(k=0;k<num;k++)
                    if(c[k]==aa[j])
                    count[j]++;
            }
            //输出
            printf("%d={",bb[i]);
            for(j=0;j<w-1;j++)
                printf("%d=%d,",aa[j],count[j]);
            printf("%d=%d}\n",aa[w-1],count[w-1]);
        }
    }
}

//算法思想：将第一组元素分别存入vector和set中。存入set中是为了去充。第二组数据
//也是同样的操作。然后map中将set2的每一元素对应于set1中所有的元素组合置零操作。
//再将map对应的元素加一操作，然后进行打印。
#include<map>
#include<vector>
#include<iostream>
#include<set>
using namespace std;
int main(int argc, char const *argv[])
{
    int num,n;
    std::vector<int> v1;
    std::vector<int> v2;
    set<int> s1;
    set<int> s2;
    map<int,int> mp[10000];
    while(scanf("%d",&num)!=EOF)
    {
        while(num--)
        {
            scanf("%d",&n);
            int temp,count;
            for (int i = 0; i < n; ++i)
            {
                scanf("%d",&temp);
                v1.push_back(temp);//将第一组数存入vector
                s1.insert(temp);//将第一组数存入set
            }
            for (int i = 0; i < n; ++i)
            {
                scanf("%d",&temp);
                v2.push_back(temp);//将第二组数存入vector
                s2.insert(temp);//将第二组数存入set
            }
            for(set<int>::iterator it2=s2.begin(); it2!=s2.end(); it2++)//初始化
            {
                for(set<int>::iterator it1=s1.begin(); it1!=s1.end(); it1++)
                {
                    mp[*it2][*it1]=0;//初始化map
                }
            }
            for (int i = 0; i < n; ++i)//计算个数
            {
                mp[v2[i]][v1[i]]++;
            }
            for(set<int>::iterator it2=s2.begin(); it2!=s2.end(); it2++)
            {
                cout<<*it2<<"={";
                count=0;
                for(map<int,int>::iterator it=mp[*it2].begin(); it!=mp[*it2].end();it++)
                {
                    count++;
                    cout<<it->first<<"="<<it->second;
                    if(count!=s1.size())
                        printf(",");
                }
                cout<<"}"<<endl;
                mp[*it2].clear();
            }
            v1.clear();
            v2.clear();
            s1.clear();
            s2.clear();
        }
    }
    return 0;
}

就我一个觉得第一个数字真的很多余吗。。。。搞了很久发现是这个错误

	#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>



	int flag[1001];
int A[1001];
int B[1001];
int count_AB[1001][1001];  //表示i在j集合里面的数目
int main() {



	    int m, n;
    while(scanf("%d", &m) != EOF) {
        int x;
        for(x=m;x>0;x--)
        {
        scanf("%d", &n);
        memset(flag, 0, sizeof(flag));
        memset(count_AB, 0, sizeof(count_AB));
        int i, j;
        for(i = 0; i < n; i++) {
            scanf("%d", &A[i]);
        }
        for(i = 0; i < n; i++) {
            scanf("%d", &B[i]);
            int a = A[i];
            int b = B[i];
            flag[b] = 1; //对应的表示这个集合存在
            count_AB[a][b]++;
        }
        //把重复的去掉之后进行冒泡排序
        int newA[1001];
        int count = 0; //这个是用来记住去掉重复之后的数组大小
        int newflag[1001];
        memset(newflag, 1, sizeof(newflag));
        for(i = 0; i < n; i++) {
            if(newflag[i]) {
                newA[count++] = A[i];
                for(j = i + 1; j < n; j++) {
                    if(A[i] == A[j] )
                        newflag[j] = 0; //出现重复
                }
            }
        }
        //进行冒泡排序
        for(i = 0; i < count - 1; i++) {
            for(j = 0; j < count - 1 - i; j++) {
                if(newA[j] > newA[j + 1]) {
                    int temp = newA[j];
                    newA[j] = newA[j + 1];
                    newA[j + 1] = temp;
                }
            }
        }
        for(i = 0; i <= n; i++) {
            if(flag[i] == 1) { //该集合存在
                //并且i的值就是集合号
                printf("%d={", i);
                for(j = 0; j < count; j++) {
                    if(j != count - 1) {
                        printf("%d=%d,", newA[j], count_AB[newA[j]][i]);
                    } else {
                        printf("%d=%d}", newA[j], count_AB[newA[j]][i]);
                    }
                }
                printf("\n");
            }
        }
        }
    }
    return 0;
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext()) {
			int m = scanner.nextInt();
			for(int i = 0;i < m; i++) {
				
				int n = scanner.nextInt();
				
				//保存数的数组
				int[] arr = new int[n];
				//保存组的数组
				int[] group = new int[n];
			
				//用来统计不同数的情况，排除重复
				List<Integer> arrList = new ArrayList<Integer>();
				//用来统计不同组的情况，排除重复
				List<Integer> groupList = new ArrayList<Integer>();
				
				for (int j = 0; j < n; j++) {
					arr[j] = scanner.nextInt();
					if (!arrList.contains(arr[j])) {
						arrList.add(arr[j]);
					}
				}

				//数按顺序排列
				Collections.sort(arrList);
				
				for (int j = 0; j < n; j++) {
					group[j] = scanner.nextInt();
					if (!groupList.contains(group[j])) {
						groupList.add(group[j]);
					}
				}
				
				//组按顺序排列
				Collections.sort(groupList);
				
				for (int j = 0; j < groupList.size(); j++) {
					
					System.out.print(groupList.get(j)+"={");
					
					for (int k = 0; k < arrList.size(); k++) {
						
						System.out.print(arrList.get(k)+"=");
						
						//用来统计该组中，某数出现的次数
						int sum = 0;
						
						for (int k2 = 0; k2 < n; k2++) {
							
							if (arr[k2] == arrList.get(k) && group[k2] == groupList.get(j)) {
								sum++;
							}
						}
						if(k == arrList.size()-1) {
							//如果是最后一个则后面加"}"
							System.out.println(sum+"}");
						}else {
							//如果不是末尾则后面加","
							System.out.print(sum+",");
						}
					}
					
				}
				
			}
		}
	}
}

//经测试，本题实际分组不是顺序递增，而是有间断不连续的
#include <iostream>
#include <map>
#include <algorithm>
#include <vector>
using namespace std;
struct Number{
    int data;
    int group;
};
int main(){
    int m;
    cin >> m;
    while(m--){
        int n;
        cin >> n;
        Number arr[n];
        for(int i=0; i<n; ++i){
            cin >> arr[i].data;
        }
        int M = -1e9;
        for(int i=0; i<n; ++i){
            cin >> arr[i].group;
            M = max(M, arr[i].group);    //最大组数
        }
        vector<bool> exist(M+1, false);    //只是为了赋初值
        for(int i=0; i<n; ++i){
            exist[arr[i].group] = true;    //标记目标分组
        }
        map<int, int> mymap[M+1];
        for(int j=1; j<=M; ++j){
            if(exist[j]){        //仅针对目标分组
                for(int i=0; i<n; ++i) {
                    mymap[j][arr[i].data] = 0;    //为所有数建立映射，次数初始都为0；
                }
            }
        }
        for(int i=0; i<n; ++i){    //统计数量
            mymap[arr[i].group][arr[i].data]++;
        }
        for(int i=1; i<=M; ++i){
            if(exist[i]){    //输出结果，仅针对实际存在的组
                cout << i << "={";
                for(auto it=mymap[i].begin(); it!=mymap[i].end();){
                    cout << it->first << "=" << it->second;
                    if(++it!=mymap[i].end()) cout << ",";
                }
                cout << "}" << endl;
            }
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        for (int i = 0; i < m; i++) {
            int n = sc.nextInt();
            int a[] = new int[n];
            int c[] = new int[n];
            Map<Integer, String> map = new HashMap<>();
            Set<Integer> set = new HashSet<>();
            for (int j = 0; j < n; j++) {
                a[j] = sc.nextInt();
                set.add(a[j]);
            }
            for (int j = 0; j < n; j++) {
                c[j] = sc.nextInt();
            }
            for (int j = 0; j < n; j++) {
                if (!map.containsKey(c[j])) {
                    map.put(c[j], "" + a[j]);
                } else {
                    map.replace(c[j], map.get(c[j]) + " " + a[j]);
                }
            }
            Object []obj = set.toArray();
            Arrays.sort(obj);
            for (Integer x : map.keySet()) {
                System.out.print(x + "={");
                print(x, map, obj);
                System.out.println("}");
            }
        }
    }

    private static void print(Integer x, Map<Integer, String> map, Object[] obj) {
        // TODO 自动生成的方法存根
        String s = map.get(x);
        String ss[] = s.split(" ");
        for (int i = 0; i < obj.length; i++) {
            int count = 0;
            for (int j = 0; j < ss.length; j++) {
                if (Integer.parseInt(ss[j]) == (Integer)obj[i]) {
                    count++;
                }
            }
            if (i != obj.length - 1)
                System.out.print(obj[i] + "=" + count + ",");
            else
                System.out.print(obj[i] + "=" + count);
        }
    }
}

#include<iostream>
#include<cstdio>
#include<string.h>
#include<stdio.h>
#include<algorithm>
using namespace std;

int hasnt(int sset[],int pos,int num){
    for(int i=0;i<pos;i++){
        if(sset[i]==num){
            return 0;
        }
    }
    return 1;
}

int main(){
    int m;
    while(cin>>m){
        for(int time=0;time<m;time++){
            int n;
            cin>>n;
            int hash[100][1001];
            memset(hash,-1,sizeof(hash));  //二维数组初始化
            int a[n],b[n],sset1[1001],sset2[100];
            int pos1=0;
            memset(sset1,1001,sizeof(sset1));
            for(int i=0;i<n;i++){
                cin>>a[i];
                if(hasnt(sset1,pos1,a[i])){
                    sset1[pos1++]=a[i];
                }         
            }
            sort(sset1,sset1+pos1);
            int pos2 = 0;
            memset(sset2,101,sizeof(sset2));
            for(int i=0;i<n;i++){
                cin>>b[i]; 
                if(hasnt(sset2,pos2,b[i])){
                    sset2[pos2++]=b[i];
                }   
                if(hash[b[i]][a[i]]==-1){
                    hash[b[i]][a[i]]=1;
                }else{
                    hash[b[i]][a[i]]++;
                }
            }
            sort(sset2,sset2+pos2);
            for(int i=0;i<pos2;i++){
                cout<<sset2[i]<<"={";
                for(int j=0;j<pos1;j++){
                    int cnt = hash[sset2[i]][sset1[j]];
                    if(cnt==-1) cnt=0;
                    if(j==pos1-1) cout<<sset1[j]<<"="<<cnt<<"}"<<endl;
                    else cout<<sset1[j]<<"="<<cnt<<",";
                }
            }
        }
    }
}

#include <bits/stdc++.h>
using namespace std;
#define N 1e5+5

vector<int> v;
map<int,map<int,int> >mp;
int main(){
	int m,n,t;
	cin>>m;
	while(m--){
		v.clear();mp.clear();
		cin>>n;
		for(int i=0;i<n;i++){
			cin>>t;
			v.push_back(t);
		}
		for(int i=0;i<n;i++){
			cin>>t;
			mp[t][v[i]]++;
		}
		for(auto p=mp.begin();p!=mp.end();p++){
			for(auto q=v.begin();q!=v.end();q++)
				if((p->second).find(*q)==(p->second).end())(p->second)[*q]=0;
		}
		for(auto p=mp.begin();p!=mp.end();p++){
			cout<<p->first<<"={";
			for(auto q=(p->second).begin();q!=(p->second).end();q++){
				if(q!=(p->second).begin())cout<<",";
				cout<<q->first<<"="<<q->second;
			}	
			cout<<"}"<<endl;
		}
	}
	return 0;
}

#include<iostream>
#include<queue>
#include<map>
using namespace std;

int main()
{
    int m,n,f;
    while(cin >> m)
    {
        while(m--)
        {
            map<int,int> p;
            map<int,map<int,int>> p1;
            cin >> n;
            int t[n];
            for(int i = 0;i < n;i++)
            {
                cin >> t[i];
                if(!p.count(t[i])) p[t[i]] = 0;
            }
            for(int i = 0;i < n;i++)
            {
                cin >> f;
                if(p1.count(f))
                {
                    p1[f][t[i]]++;
                }
                else
                {
                    p1[f] = p;
                    p1[f][t[i]]++;
                }
            }
            for(auto q : p1)
            {
                cout << q.first << "={";
                int i = 0;
                for(auto r : q.second)
                {
                    if(i == 0) cout << r.first << "=" << r.second;
                    else cout << "," << r.first << "=" << r.second;
                    i++;
                }
                cout << "}" << endl;
            }
        }
    }
    return 0;
}

#include<iostream>
#include<numeric>
#include<string>
#include<vector>
#include<math.h>
#include<map>
#include<set>
#include<algorithm>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
using namespace std;


int main() {
    int n;
    while (scanf("%d", &n) != EOF) {
        for (int i = 0; i < n; i++) {
            int len;
            cin >> len;
            vector<int> data;
            for (int j = 0; j < len; j++) {    
                int num;
                cin >> num;
                data.push_back(num);
            }
            vector<int> ind;
            for (int j = 0; j < len; j++) {    
                int index;
                cin >> index;
                ind.push_back(index);
            }


            map<int, vector<int>> mp;
            for (int i = 0; i < len; i++) {
                mp[ind[i]].push_back(data[i]);
            }

            set<int> st(data.begin(),data.end());
            set<int>::iterator sit;
            set<int>::reverse_iterator rsit = st.rbegin();
            map<int, vector<int>>::iterator mit;
            for (mit = mp.begin(); mit != mp.end(); mit++) {
                cout << (*mit).first << "={";

                for (sit = st.begin(); sit != st.end(); sit++) {
                    cout <<(*sit)<<"=" << count((*mit).second.begin(),(*mit).second.end(),(*sit));
                    if((*sit) != (*rsit)){
                         cout << ",";
                    }
                }
                cout << "}" << endl;
            }

        }
    }
    return 0;
}