合并表记录

import java.util.*;
import java.lang.*;
import java.text.*;
import java.math.*;
import java.util.stream.Collectors;
import static java.util.Map.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
		while(sc.hasNext())
        {
			int num = sc.nextInt();
            Map<Integer,Integer> map=new HashMap();
            for(int i=0;i<num;i++){
                int key = sc.nextInt();
                int value = sc.nextInt();
                map.put(key,map.getOrDefault(key,0)+value);
            }
			List<Entry<Integer, Integer>> collect = map.entrySet().stream().sorted((o1, o2)->{
                return o1.getKey() - o2.getKey();
                }
            ).collect(Collectors.toList());
            for (Entry<Integer, Integer> entry : collect) {
                System.out.println(entry.getKey()+" "+entry.getValue());
            }
        }
		sc.close();
    }
}

#include<stdio.h>
struct data{  //构造结构体类型
    int index;
    int value;
};
int main(void)
{
    struct data temp[500]; //创建结构体数组
    int n;
    scanf("%d",&n);//输入个数n
    for(int i=0;i<n;i++)
    {
        scanf("%d %d",&temp[i].index,&temp[i].value);//输入下标值与内容值
    }
    //选择排序，将具有相同下标值的结构体数组元素变为相邻的
    for(int i=0;i<n-1;i++)
    {
        int min=i,j;
        for(j=i+1;j<n;j++)
        {
            if(temp[min].index>temp[j].index)
            {
                min=j;
            }
        }
        if(min!=j)
        {
            struct data ll=temp[i];
            temp[i]=temp[min];
            temp[min]=ll;
        }
    }
    /*将相邻的结构体数组元素的下标值进行比较，若相同则将下标大的内容值加到小标小
    的元素中，再将下标大的元素的下标值置为 -1*/
    for(int k=n-1;k>0;k--)
    {
        if(temp[k].index==temp[k-1].index)
        {
            temp[k-1].value+=temp[k].value;
            for(int j=k;j<n-1;j++)
            {
                temp[k]=temp[k+1];
            }
            temp[k].index=-1;
        }
    }
    //遍历输出数组元素，注意判断其下标值是否为 -1，不是就输出，否则不输出
    for(int i=0;i<n;i++)
    {
        if(temp[i].index!=-1)
        printf("%d %d\n",temp[i].index,temp[i].value);
    }
    return 0;
}

运用一个数学上的小技巧：

1. 已知题目输入键值对的个数 n（1 <= n <= 500）可以让输入的key乘上键值对的最大值然后加上索引值放到key数组里，输入的value放在value数组的对应索引里，遇到相同的key值就在对应位置上累加value，这样我们可以得到两个数组，相同的索引（数组下标）即是key对应的value。
2. 然后我们对key数组进行排序，因为索引值一定会小于等于输入键值对的个数，所以索引值并不会影响排序结果，排序仍会按照key的大小进行排序
3. 最后我们按照排序后的key数组进行输出，key[i]对键值对的最大值整除即可得到key值，取余得到索引即可在value数组中找到对应的value值。

#include
#define MAX 500
#define long long size_t
int cmp(size_t *a, size_t *b){
    return (int)(*a - *b);
}
int main(){
    int num = 0, temp1 = 0, temp2 = 0, size = 0, flag = 0;
    scanf("%d\n",&num);
    size_t *key = malloc(num*sizeof(size_t));
    int *value = malloc(num*sizeof(int));
    memset(key,-1,num*sizeof(size_t));
    for(int i=0; i<num; i++){
        flag = 1;
        scanf("%d %d\n",&temp1,&temp2);
        for(int a=1; a<=size; a++){
             if(temp1 == key[a]/MAX){
                 value[a] += temp2;
                 flag = 0;
             }
        }
        if(flag){
            size++;
            key[size] = (temp1*MAX)+size;
            value[size] = temp2;
        }
    }
    qsort(key,size+1,sizeof(size_t),cmp);
    for(int j = 1; j<=size; j++){
        printf("%d %d\n",key[j]/MAX,value[key[j]%MAX]);
    }
}

count = int(input(''))
d = {}
for i in range(count):
    k, v = map(int, input('').split(' '))
    if k in d:
        d[k] += v
    else:
        d[k] = v
res = sorted(d.items(),key=lambda item:item[0])
for r in res:
    print('{} {}'.format(r[0], r[1]))

#输入键值对个数
n = int(input())
l1 = []
l2 = []
#键值分别出存在l1和l2中
for i in range(n):
    a,b=input().split()
    a = int(a)
    b = int(b)
#如果键重复，则对应的值做加法运算
    if a in l1:
        d = l1.index(a)
        l2[d] += b
    else:
        l1.append(a)
        l2.append(b)
#将新的键值对合并到新的列表l中，排序后输出
l = list(zip(l1,l2))
l.sort()
for each in l:
    print(each[0],each[1])

public static void main(String[] args) {
        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
        Scanner sc = new Scanner(System.in);
        int num = Integer.parseInt(sc.nextLine());
        while (num>0) {
            String str = sc.nextLine();
            String[] mapStr = str.split(" ");
            Integer key = Integer.valueOf(mapStr[0]);
            Integer value = Integer.valueOf(mapStr[1]);
            if (!treeMap.containsKey(key)) {
                treeMap.put(key, value);
            } else {
                treeMap.put(key, treeMap.get(key) + value);
            }
            num--;
        }
        for (Map.Entry<Integer, Integer> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        Map<Integer, Integer> result = new TreeMap<Integer, Integer>();
        int pairs = 0;
        if (scanner.hasNextInt()){
            pairs = scanner.nextInt();
        }
        for (int i = 0; i < pairs; i++){
            int idx = scanner.nextInt();
            int value = scanner.nextInt();
            if (result.containsKey(idx)){
                result.put(idx,result.get(idx) + value);
            }
            else{
                result.put(idx,value);
            }
        }
        for (Integer key : result.keySet()){
            System.out.printf("%d %d%n",key, result.get(key));
        }
    }
}

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int size = scanner.nextInt();
            if (size < 1) {
                continue;
            }
            TreeMap<Integer, Integer> treeMap = new TreeMap<>();
            for (int i = 0; i <= size; i++) {
                String line = scanner.nextLine().trim().replaceAll("\\s", " ");
                String[] arr = line.split(" ");
                if (arr.length != 2) {
                    continue;
                }
                try {
                    int first = Integer.parseInt(arr[0]);
                    int second = Integer.parseInt(arr[1]);
                    if(treeMap.containsKey(first)){
                        int newValue = treeMap.get(first) + second;
                        treeMap.put(first, newValue);
                    } else {
                        treeMap.put(first, second);
                    }
                } catch (NumberFormatException e) {
                    continue;
                }
            }
            treeMap.forEach((key, value) -> System.out.println(key + " " + value));
        }
    }

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    int NumberCount=0;
    while(cin>>NumberCount)
    {
       vector<int> Number(NumberCount,0);
       int   Index=0,Value=0;
       for(int i=0;i<NumberCount;i++)
       {
          cin>>Index;
          cin>>Value;
          Number[Index]=Number[Index]+Value;
       }
       for(int i=0;i<NumberCount;i++)
       {
           if(Number[i]>0)
           {
              cout<<i<<" "<<Number[i]<<endl;
           }
       }
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main(){
    int n;
    while(cin>>n){
        map<int,int> helper;
        int key,value;
        for(int i=0;i<n;++i) {
            cin >> key >> value;
            helper[key] += value;
        }
        for(map<int,int>::const_iterator it=helper.cbegin();it != helper.cend();++it)
            cout << it->first << ' ' << it->second << endl;
    }
    return 0;
}

import java.util.*;

/**
 * @author 风清扬
 * @version 1.0
 * @data 2020/5/21
 **/
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int count = sc.nextInt();
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < count; i++) {
                int key = sc.nextInt();
                int value = sc.nextInt();
                if (map.containsKey(key)) {
                    value = map.get(key) + value;
                    map.put(key, value);
                }
                map.put(key, value);
            }
            Set<Integer> keys = map.keySet();
            List<Integer> list = new ArrayList<Integer>();
            for (Integer key : keys) {
                list.add(key);
            }
            Collections.sort(list);
            for (Integer integer : list) {
                System.out.println(integer + " " + map.get(integer));
            }
        }
    }
}

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        Map<Integer,Integer> map = new TreeMap<>();
        for(int i = 0;i<n;i++){
            String[] str = br.readLine().split(" ");
            int key = Integer.parseInt(str[0]);
            int value = Integer.parseInt(str[1]);
            if(map.containsKey(key)){
                map.put(key,map.get(key)+value);
            }else
                map.put(key,value);
        }
        for(Integer key:map.keySet()){
            System.out.println(key + " " + map.get(key));
        }
        
    }
}

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct Record
{
    public:
        Record(int x,int y):index(x),val(y){};
    public:
        int index;
        int val;
};
bool intComp(const struct Record &a,const struct Record &b)
{
   return a.index < b.index || (a.index == b.index && a.val < b.val);
}
int main()
{
    int n;
    cin>>n;
    vector<Record> vec;
    int index;
    int val;
    for(int i=0;i<n;++i)
    {
        cin >> index >> val;
        Record record(index,val);
        vec.push_back(record);   
    }
    sort(vec.begin(),vec.end(),intComp);
    vector<Record> ans;
    int low=0;
    int high=0;
    for(int i=0;i<n;++i)
    {
        if(i+1<n&&vec[i].index==vec[i+1].index)
        {
                high = i+1;
        }
        else
        {
            int x=vec[low].index;
            int y=vec[low].val;
            for(int j=low+1;j<=high;++j)
            {
                y+=vec[j].val;
            }
            cout << x << " " << y << endl;
            low = high+1;
            high = low;
        }
    }
    return 0;
}