TopCoder SRM 660 Div1 250

然而我只得了95，太弱..

给一个 $n$ 行 $m$ 列的矩阵，矩阵元素为0-9，表示权值。现在给不超过10个集合{dx,dy}，表示如果我选择了(i,j)，则我就选择了集合里每个(i+dx , j+dy)点。现在要求你选择两个不同的点作为中心点（当然，它们拓展出来的点可能会重合），使得被选择的点（重复只能算一次）权值之和最大。。觉得不理解的，看tc的描述吧。

N,M 在100内，且都>=2，其他数据都在合法范围内。

这种题就乱搞。题目里数据范围小的变量往往是突破点，先说我的想法吧，一共有10000个点，对于每个(i,j)，它拓展出来的点称为一个状态。那么与该状态有交集的状态最多有90个，我们不妨预处理出10000个状态，这个复杂度是O(N*M*10)的，这些状态存在一个集合里，然后暴力看每一个状态，把与它有交集的状态从集合中取出来放在另一个容器里，这个复杂度是O(N*M*90*log)的，这样，原容器里的状态都是与该状态没有交集的状态，我只需要取一个总和最大的出来就好（不需要一个一个判断，大大降低复杂度），对于新容器的状态，是有交集的，但由于不超过90个，直接暴力判，每次判是O(10)的复杂度，总共是O(N*M*90*10)。tc单case 而 跑的飞快，妥妥没问题。。比赛时候，第三步，我傻逼写成了O(N*M*90*10*log)的复杂度都1.998秒过了。。

然而我的方法不优越，说下林队长的。。你想，每个状态与它有交集的不超过90个，我把状态预处理出来，按权值和从大到小排个序，是不是取前91个，就一定能找到一个与它没有交集的且权值和最大的？那是不是排个序后，只需要枚举前91个内部就行了？92开始就不用管了。。复杂度是O(91*91*10)，当然，预处理是O(N*M*10)+O(N*M*log)，快得飞起。

林队长的方法

//Hello. I‘m Peter.
//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<iostream>
#include<sstream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<cctype>
#include<ctime>
#include<stack>
#include<queue>
#include<deque>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
#define peter cout<<"i am peter"<<endl
#define INT (0x3f3f3f3f)*2
#define LL (0x3f3f3f3f3f3f3f3f)*2
#define N 120
int n,m,lenset;
struct Data{
    int r,c;
    int sumval;
}data[N*N];
int numdata;
inline bool comp(const Data a,const Data b){
    return a.sumval>b.sumval;
}
int vis[N][N],nowkase;
inline bool legal(int x,int y){
    return x>=0&&x<n&&y>=0&&y<m;
}
class Coversta{
public:
    int cal(vector<string>&a,vector<int>&x,vector<int>&y,int x1,int y1,int x2,int y2){
        nowkase++;
        int sumval=0;
        for(int i=0;i<lenset;i++){
            int zx=x1+x[i];
            int zy=y1+y[i];
            if(!legal(zx,zy)) continue;
            if(vis[zx][zy]!=nowkase){
                vis[zx][zy]=nowkase;
                sumval+=a[zx][zy]-‘0‘;
            }
        }
        for(int i=0;i<lenset;i++){
            int zx=x2+x[i];
            int zy=y2+y[i];
            if(!legal(zx,zy)) continue;
            if(vis[zx][zy]!=nowkase){
                vis[zx][zy]=nowkase;
                sumval+=a[zx][zy]-‘0‘;
            }
        }
        return sumval;
    }
    int place(vector <string> a, vector <int> x, vector <int> y){
        memset(vis,-1,sizeof(vis));
        nowkase=0;
        lenset=(int)x.size();
        n=(int)a.size();
        m=(int)a[0].length();
        numdata=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                int sumval=0;
                for(int k=0;k<lenset;k++){
                    int zx=i+x[k];
                    int zy=j+y[k];
                    if(!legal(zx,zy)) continue;
                    int val=a[zx][zy]-‘0‘;
                    sumval+=val;
                }
                int t=++numdata;
                data[t].r=i,data[t].c=j,data[t].sumval=sumval;
            }
        }
        int ans=-1;
        sort(data+1,data+1+numdata,comp);
        numdata=min(numdata,91);
        for(int i=1;i<=numdata;i++){
            for(int j=1;j<=numdata;j++){
                if(i==j) continue;
                ans=max(ans,cal(a,x,y,data[i].r,data[i].c,data[j].r,data[j].c));
            }
        }
        return ans;
    }
};

我的傻逼方法

//Hello. I‘m Peter.
//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<iostream>
#include<sstream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<cctype>
#include<ctime>
#include<stack>
#include<queue>
#include<deque>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
#define peter cout<<"i am peter"<<endl
#define INT (0x3f3f3f3f)*2
#define LL (0x3f3f3f3f3f3f3f3f)*2
#define N 120
int n,m,lenset;
vector<string>at;
struct Data{
    vector<pair<int,int> >v;
    int sumval;
}data[N][N];
struct Data2{
    int x,y,sumval;
    friend bool operator<(const Data2 A,const Data2 B){
        if(A.sumval!=B.sumval) return A.sumval>B.sumval;
        else if(A.x!=B.x) return A.x<B.x;
        else return A.y<B.y;
    }
}data2;
set<Data2>se;
int vis[N][N],nowkase;
inline bool legal(int x,int y){
    return x>=0&&x<n&&y>=0&&y<m;
}
class Coversta{
public:
    int cal(int x1,int y1,int x2,int y2){
        nowkase++;
        int len,sumval=0;
        len=(int)data[x1][y1].v.size();
        for(int i=0;i<len;i++){
            int x=data[x1][y1].v[i].first;
            int y=data[x1][y1].v[i].second;
            if(vis[x][y]!=nowkase){
                vis[x][y]=nowkase;
                sumval+=at[x][y]-‘0‘;
            }
        }
        len=(int)data[x2][y2].v.size();
        for(int i=0;i<len;i++){
            int x=data[x2][y2].v[i].first;
            int y=data[x2][y2].v[i].second;
            if(vis[x][y]!=nowkase){
                vis[x][y]=nowkase;
                sumval+=at[x][y]-‘0‘;
            }
        }
        return sumval;
    }
    int place(vector <string> a, vector <int> x, vector <int> y){
        memset(vis,-1,sizeof(vis));
        nowkase=0;
        at=a;
        lenset=(int)x.size();
        n=(int)a.size();
        m=(int)a[0].length();
        se.clear();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                data[i][j].v.clear();
                int sumval=0;
                for(int k=0;k<lenset;k++){
                    int zx=i+x[k];
                    int zy=j+y[k];
                    if(!legal(zx,zy)) continue;
                    pair<int,int>p=make_pair(zx,zy);
                    int val=a[zx][zy]-‘0‘;
                    sumval+=val;
                    data[i][j].v.push_back(p);
                }
                data[i][j].sumval=sumval;
                data2.x=i,data2.y=j,data2.sumval=sumval;
                se.insert(data2);
            }
        }
        int ans=-1;
        queue<Data2>q;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                while(!q.empty()) q.pop();
                for(int k1=0;k1<lenset;k1++){
                    int zx1=i+x[k1];
                    int zy1=j+y[k1];
                    if(!legal(zx1,zy1)) continue;
                    for(int k2=0;k2<lenset;k2++){
                        if(k1==k2) continue;
                        int zx2=zx1-x[k2];
                        int zy2=zy1-y[k2];
                        if(!legal(zx2,zy2)) continue;
                        data2.x=zx2,data2.y=zy2,data2.sumval=data[zx2][zy2].sumval;
                        if(se.find(data2)!=se.end()){
                            q.push(data2);
                            se.erase(data2);
                        }
                    }
                }
                data2.x=i,data2.y=j,data2.sumval=data[i][j].sumval;
                if(se.find(data2)!=se.end()){
                    q.push(data2);
                    se.erase(data2);
                }
                int anst=-1;
                if(!se.empty()){
                    anst=data[i][j].sumval;
                    anst+=((*se.begin()).sumval);
                    ans=max(ans,anst);
                }
                while(!q.empty()){
                    if(i!=q.front().x||j!=q.front().y){
                        anst=cal(i,j,q.front().x,q.front().y);
                        ans=max(ans,anst);
                    }
                    se.insert(q.front());
                    q.pop();
                }
            }
        }
        return ans;
    }
};