topcoder srm 707 div1

1 构造一个棋盘，长宽n,m不超过50，每个格子为障碍或者非障碍两种，使得从（0,0）到（n-1,m-1）的最短路为给定的值k。

思路：如果k小于等于98，那么一定存在没有障碍的棋盘满足要求。否则，最后的路径可以如下图所示（白色为障碍）。假设一开始向左弯曲到最左侧的次数为x，最后一次向左弯曲的长度为y，然后枚举矩形的长宽，判断是否等于k即可。

2 将s变成t，每次操作可以将s加上a，或者将s乘上b。问最少的操作次数。

思路：b为0或者1是单独讨论。现在假设b大于1.设一共经过了m次乘操作，第i次乘法操作前进行的加法操作次数为$p_{i}$,那么最后得到的值为$((((s+p_{0}a)b+p_{1}a)b+...)b+p_{m-1}a)b+p_{m}$$=sb^{m}+a\sum_{i=0}^{m}p_{i}b_{m-i}$。所以首先枚举m，那么$\sum_{i=0}^{m}p_{i}b_{m-i}=\frac{t-sb^{m}}{a}$。这时候贪心即可确定各个$p_{i}$，答案为$m+\sum_{i=0}^{m}p_{i}$

void up(long long &x,long long y)
{
    if(x==-1||x>y) x=y;
}

class MultiplyAddPuzzle {
public:
    long long minimalSteps(long long s, long long t, long long a, long long b)
    {
        if(s==t) return 0;
        if(b==0)
        {
            if(t==0) return 1;
            if(a==0) return -1;
            if(t>s&&(t-s)%a==0) return (t-s)/a;
            if(t%a==0) return t/a+1;
            return -1;
        }
        if(b==1)
        {
            if(a==0) return -1;
            if(t>s&&(t-s)%a==0) return (t-s)/a;
            return -1;
        }

        long long p[63];
        p[0]=1;
        for(int i=1;i<63;++i) p[i]=p[i-1]*b;
        long long ans=-1;

        for(int m=0;m<62;++m)
        {
            if(a==0)
            {
                if(t%p[m]==0&&t/p[m]==s) up(ans,m);
            }
            else
            {
                if(t/p[m]<s) break;
                if((t-p[m]*s)%a==0)
                {
                    long long S=(t-p[m]*s)/a;
                    long long curAns=m;
                    for(int i=m;i>=0;--i)
                    {
                        curAns+=S/p[i];
                        S-=S/p[i]*p[i];
                    }
                    up(ans,curAns);
                }
            }
            if(b>t/p[m]) break;
        }
        return ans;
    }
};

　3 有一个棋盘，棋盘的某些位置上放有棋子。有依次执行的若干操作，每个操作是将其中的一个棋子移动a到相邻的某个格子b上。每次移动时，要求a上必须有一个棋子，b上没有棋子。对于一个操作序列，若存在某个初始的棋盘使得该操作序列的每个操作都合法，那么称该操作序列合法。求最少删掉操作序列的多少个操作可以使得上下的序列合法。

思路： $u$移动到$v$，增加三条边，如下图所示。所有边流量均为1，代价除了-1外都为0.源点到所有的点连边，代表每个节点最后的节点到汇点连边。最后求最小费用最大流。费用为非负时结束查找可行流。得到的费用的绝对值就是不需要删除的操作。

#include <map>
#include <string>
#include <stdio.h>
#include <vector>
#include <set>
#include <algorithm>
#include <string.h>
#include <iostream>
#include <stack>
#include <queue>
using namespace std;

const int N=5000;

const int INF=10000000;

struct node
{
    int u,v,flow,cost,next;
};

node edges[N*100];
int head[N],e;

void add(int u,int v,int flow,int cost)
{
    edges[e].u=u;
    edges[e].v=v;
    edges[e].cost=cost;
    edges[e].flow=flow;
    edges[e].next=head[u];
    head[u]=e++;
}

void Add(int u,int v,int flow,int cost)
{
    add(u,v,flow,cost);
    add(v,u,0,-cost);
}

int C[N],F[N],pre[N];
int visit[N];

int SPFA(int s,int t)
{
    memset(pre,-1,sizeof(pre));
    queue<int> Q;
    Q.push(s);
    int i;
    for(i=0;i<=t;i++) C[i]=INF,F[i]=0,visit[i]=0;
    int u,v,c,f;
    C[s]=0; F[s]=INF;
    while(!Q.empty())
    {
        u=Q.front();
        Q.pop();

        visit[u]=0;
        for(i=head[u];i!=-1;i=edges[i].next)
        {
            v=edges[i].v;
            c=edges[i].cost;
            f=edges[i].flow;
            if(f>0&&C[v]>C[u]+c)
            {
                C[v]=C[u]+c;
                F[v]=min(F[u],f);
                pre[v]=i;
                if(!visit[v])
                {
                    Q.push(v);
                    visit[v]=1;
                }
            }
        }
    }
    if(C[t]>=0) return 0;
    return F[t];
}

int MCMF(int s,int t)
{
    int ans=0,i,temp,x;
    while(temp=SPFA(s,t))
    {
        for(i=t;i!=s;i=edges[pre[i]].u)
        {
            x=pre[i];
            ans+=temp*edges[x].cost;
            edges[x].flow-=temp;
            edges[x^1].flow+=temp;
        }
    }
    return ans;
}

int get(int x,int y)
{
    return x*60+y;
}

int p[5000];

class AncientGameRecord {
public:
    int minimalRemove(int n, int m, vector <int> x, vector <int> y, string d)
    {
        memset(head,-1,sizeof(head));
        const int K=(int)x.size();
        int cnt=0;
        for(int i=0;i<K;++i)
        {
            int x1=x[i],x2=x[i];
            int y1=y[i],y2=y[i];
            if(d[i]=='D') ++x2;
            if(d[i]=='U') --x2;
            if(d[i]=='L') --y2;
            if(d[i]=='R') ++y2;

            if(x2==-1||x2==n||y2==-1||y2==m) continue;
            int c1=get(x1,y1);
            int c2=get(x2,y2);
            Add(p[c1],cnt+1,1,0);
            Add(p[c2],cnt+2,1,0);
            Add(cnt+1,cnt+2,1,-1);
            p[c1]=cnt+1;
            p[c2]=cnt+2;
            cnt+=2;
        }
        int sink=cnt+1;
        for(int i=0;i<n;++i) for(int j=0;j<m;++j) if(p[get(i,j)])
        {
            Add(p[get(i,j)],sink,1,0);
        }
        return K+MCMF(0,sink);
    }
};