【TCO2013 Round1A】Solutions

　　230来分就晋级了，偏偏我出了点事故第一题低分，第二题被cha，第三题没时间写。。。准备滚回去R1B了。。。

【250】

　　大意是一个n×m的矩阵，每次可以将一个格子中的数±1，问最少操作次数使得最大值与最小值相差不超过1。格子中的数值为0~9。

　　枚举最小值min，最大值max=min+1，然后挨着判断一下。

class HouseBuilding {
public:
    int getMinimum(vector <string>);
};

int HouseBuilding::getMinimum(vector <string> area) {
    int n=area.size();
    int len=area[0].length();
    int ans=inf;
    for(int low=0;low<9;low++){
            int tmp=0;
            for(int i=0;i<n;i++)
                for(int j=0;j<len;j++){
                    int cur=area[i][j]-'0';
                    if(cur>low+1) tmp+=(cur-low-1);
                    else if(cur<low) tmp+=(low-cur);
                }
            gmin(ans,tmp);
        }
    return ans;
}

【500】

　　给定若干区间，求最小的公差d使得等差数列{0,d,2d...nd},nd>D，且an不在区间内（不包括边界）。

　　感觉这题比较难，因为区间坐标都是整数，所以d≥1，对于每个区间的右端点R[i]，枚举k使得kd≥R[i]，然后判断是否(k-1)d≤L[i].判断方法当时没想粗，然后乱写了一个，果断被cha。。。

class TheFrog {
public:
    double getMinimum(int, vector <int>, vector <int>);
};

double TheFrog::getMinimum(int D, vector <int> L, vector <int> R) {
    int n=L.size();
    double ans=1e100;
    for(int i=0;i<n;i++){
        for(int step=1;step<=R[i];step++){
            bool check=true;
            double len=R[i]*1.0/step;
            if(len>=(double)D) gmin(ans,(double)D);
            for(int j=0;j<n;j++){
                if(floor(L[j]*1.0/len+eps)*len+len+eps<R[j]){
                    check=false;
                    break;
                }
            }
            if(check) gmin(ans,R[i]*1.0/step);
        }
    }
    return ans;
}

【1000】

　　打开这题的时候已经没时间了。。。

　　要求改变最少的箭头使得任意一个点都在环内。

　　任意一个点属于一个环 ↔每个点出度入度都是1

　　拆点，连边时与原箭头方向相同费用为0，不同费用为1。最大流即保证出入度为1，即任意一个点属于一个环。跑最小费用流。

struct EDGE{
        int pnt,cap,cost;
        EDGE *pre,*ref;
        EDGE(){}
        EDGE(int _pnt,int _cap,int _cost,EDGE *_pre):pnt(_pnt),cap(_cap),cost(_cost),pre(_pre){}
    }Edge[mm],*SP=Edge,*edge[mn],*path[mn];

    queue<int> q;
    int dist[mn],mincost,source,sink;
    bool vis[mn];
    char dir[4]={'D','U','L','R'};

class DirectionBoard {
public:
    int getMinimum(vector <string>);
};

void addedge(int a,int b,int c){
    edge[a]=new(++SP)EDGE(b,1,c,edge[a]);
    edge[b]=new(++SP)EDGE(a,0,-c,edge[b]);
    edge[a]->ref=edge[b],edge[b]->ref=edge[a];
}

bool SPFA(){
    memset(dist,0x7f,sizeof(dist));
    dist[source]=0;
    q.push(source);
    while(!q.empty()){
        int i=q.front();q.pop();
        vis[i]=false;
        for(EDGE *j=edge[i];j;j=j->pre)
            if(j->cap>0 && dist[j->pnt]>dist[i]+j->cost){
                dist[j->pnt]=dist[i]+j->cost;
                path[j->pnt]=j;
                if(!vis[j->pnt]){
                    q.push(j->pnt);
                    vis[j->pnt]=true;
                }
            }
    }
    return dist[sink]<10000;
}

void augment(){
    mincost+=dist[sink];
    for(int i=sink;i!=source;i=path[i]->ref->pnt)
        path[i]->cap--,path[i]->ref->cap++;
}

void costflow(){
    while(SPFA()) augment();
}

int DirectionBoard::getMinimum(vector <string> board) {
    int n=board.size();
    int m=board[0].length();
    int size=n*m;
    source=size*2,sink=source+1;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++){
            addedge(source,i*m+j,0);
            addedge(i*m+j+size,sink,0);
            for(int k=0;k<4;k++){
                int x=(i+dx[k]+n)%n,y=(j+dy[k]+m)%m;
                addedge(i*m+j,x*m+y+size,dir[k]!=board[i][j]);
            }
        }
    costflow();
    return mincost;
}

　　唉。。。。。真可惜。。。。。

　　转载注明出处：http://www.cnblogs.com/Delostik/archive/2013/02/24/2924316.html