基于分治法的找秩(maxium rank finding)策略

#include <algorithm>
#include <iostream>
#include <vector>
#include <cstring>

const int MAX_N = 1000;

struct  Point
{
    int x;
    int y;

};

bool cmpx(Point a, Point b)
{
    return a.x < b.x;
}

bool cmpy(Point a, Point b)
{
    return a.y < b.y;
}

int rank[MAX_N][MAX_N];

Point S[MAX_N];
//点集，起始点，终点+1
void rankFinding(Point S[], int from, int to)
{
    int n = to - from;
    if (n <= 0)
    {
        return;
    }
    if (n == 1)
    {
        rank[S[from].x][S[from].y] = 0;
        return;
    }
    std::sort(S + from, S + to, cmpx);//n*log(n)
    int l = (to + from) / 2;
    rankFinding(S, from, l);//2*T(n/2)
    rankFinding(S, l, to);
    std::sort(S + from, S + l, cmpy);//2*(n/2)*log(n/2)
    std::sort(S + l, S + to, cmpy);
    for (int i = l; i < to; ++i)
    {
        for (int j = from; j < l; ++j)
        {
            if (S[i].y > S[j].y)
            {
                rank[S[i].x][S[i].y]++;
            }
        }
    }
}

int main()
{
    memset(rank, -1, sizeof(rank));
    memset(S, 0, sizeof(S));
    S[0] = { 1, 1 };
    S[1] = { 1, 3 };
    S[2] = { 2, 5 };
    S[3] = { 6, 2 };
    S[4] = { 9, 3 };
    S[5] = { 4, 8 };
    S[6] = { 7, 6 };
    S[7] = { 5, 5 };
    S[8] = { 2, 3 };
    rankFinding(S, 0, 9);
    for (int i = 0; i < MAX_N; ++i)
    {
        for (int j = 0; j < MAX_N; ++j)
        {
            if (rank[i][j] != -1)
            {
                std::cout << i << ‘ ‘ << j << ‘ ‘ << rank[i][j] << std::endl;
            }
        }
    }
}