Problem:
Score : 700 points

Problem Statement

Takahashi is playing with N cards.

The i-th card has an integer X_i on it.

Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:

The integers on the two cards are the same.

The sum of the integers on the two cards is a multiple of M.

Find the maximum number of pairs that can be created.

Note that a card cannot be used in more than one pair.

Constraints

2≦N≦10^5

1≦M≦10^5

1≦X_i≦10^5

Input

The input is given from Standard Input in the following format:

N M
X_1 X_2 ... X_N

Output

Print the maximum number of pairs that can be created.

Sample Input 1

7 5
3 1 4 1 5 9 2

Sample Output 1

3

Three pairs (3,2), (1,4) and (1,9) can be created.

It is possible to create pairs (3,2) and (1,1), but the number of pairs is not maximized with this.

Sample Input 2

15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99

Sample Output 2

6

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <iostream>
#include <array>
#include <vector>
#include <map>
#include <utility>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <stack>
#include <deque>
#include <set>
#include <string>
#include <limits.h>
#include <algorithm>

#define MAXN 100001

using namespace std;

int main(){
    int n, m;
    cin >> n >> m;
    
    vector<int> v;
    for (int i = 0; i < n; i++) {
        int s;
        cin >>s;
        v.push_back(s);
    }
    sort(v.begin(), v.end());
    
    map<int, int> counter1;
    
    for (int i = 0; i < v.size(); i++) {
        int w = v[i];
        if (counter1.find(w) == counter1.end()) {
            counter1[w] = 1;
        }else{
            counter1[w] ++;
        }
    }
    
    map<int, int> counter2;
    int counter3[100000] = {0};
    int counter4[100000] = {0};
    for (pair<int, int> x : counter1) {
        int w = x.first % m;
        if (counter2.find(w) == counter2.end()) {
            counter2[w] = x.second;
        }else{
            counter2[w] += x.second;
        }
        if (x.second % 2 == 1) {
            counter3[w] ++;
        }
        counter4[w] ++;
    }
    
    int sum = 0;
    for (pair<int, int> w : counter2) {
        int wk = w.first;
        int counter_p = counter2.find(m-wk) == counter2.end()? 0:counter2[m-wk];
        int cc = min(w.second, counter_p);
        counter2[wk] -= cc;
        if (counter2.find(m-wk) != counter2.end()) {
            counter2[m-wk] -= cc;
        }
        sum += cc;
        //counter2[wk]/2個じゃない
        counter3[wk] -= cc;
        if (counter3[wk] <= 0) {
            sum += counter2[wk]/2;
        }else{
            sum += (counter2[wk] - counter3[wk])/2;
        }
    }
    
    cout << sum << endl;
    
    return 0;
}