合并表记录

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]);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Map;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s;
        while ((s = br.readLine()) != null) {
            TreeMap<Integer, Integer> map = new TreeMap<>();
            for (int i = 0; i < Integer.parseInt(s); i++) {
                String[] kv = br.readLine().split(" ");
                int key = Integer.parseInt(kv[0]), value = Integer.parseInt(kv[1]);
                map.put(key, map.getOrDefault(key, 0) + value);
            }
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    }
}

这个题最直接的做法就是使用TreeMap.用TreeMap有序的特性进行插入。最后遍历map即可。

import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Map map = new TreeMap();
        int N = in.nextInt();
        for (int i=0;i<N;++i) { // 注意 while 处理多个 case
            int a = in.nextInt();
            int b = in.nextInt();
            if(map.get(a)!=null){
                map.put(a,map.get(a)+b);
            }
            else map.put(a,b);
        }
        for( Map.Entry entry:map.entrySet()){
            System.out.println(entry.getKey()+" "+entry.getValue());
        }
    }
}

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 sc = new Scanner(System.in);
        int nums = sc.nextInt();
        Map<Integer,Integer> map = new TreeMap<>();
        for(int i=0;i<nums;i++){
            int index = sc.nextInt();
            int value = sc.nextInt();
            map.merge(index,value, Integer::sum);
        }
        map.forEach((k,v)->{
            System.out.println(k+" "+v);
        });
    }
}

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

int main() {
    // map：有序，红黑树             适用性：对于顺序要求高的问题，适用map会更高效点
    //unordered_map:无序，哈希表     适用性：对于查找问题更加高效
    map<int, int> hash; 
    int n;
    cin >> n;
    while(n--) {
        int a, b;
        cin >> a >> b;
        hash[a] += b;
    }
    for (auto& v : hash) {
        cout << v.first << " " << v.second << endl;
    }
    return 0;
}

var readline = require('readline');
const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
});

const obj = {}
rl.on('line', function(line){
   var tokens = line.split(' ');
    
    if(tokens[1]){
       if(obj[tokens[0]]){
           obj[tokens[0]] += Number(tokens[1])
       } else {
           obj[tokens[0]] = Number(tokens[1])
       } 
    }
});

rl.on('close',()=>{
    for (const [key, value] of Object.entries(obj)) {
       console.log(`${key} ${value}`);
    }
})