2016-2017 ACM-ICPC Pacific Northwest Regional Contest (Div.1)

A. Alphabet

题意：给出一个字符串，问最少添加多少个字母可以出现子串a-z。

题解：最长上升子序列。答案就是26减去LIS的长度。

#include
#define maxn 200050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,dp[maxn];
char s[maxn];

int main()
{
    scanf("%s",s);
    n=strlen(s);
    memset(dp,0,sizeof(dp));
    for(int i=0;is[i])
                dp[j]=max(dp[j],dp[i]+1);
        }
    }
    int ans=0;
    for(int i=0;i

B. Buggy Robot

题意：一个机器人要在迷宫里从起点走到终点，现给出了一系列指令，但机器人按照这些指令行走有可能不能到达终点。问最少需要增加/删去几条指令可以令机器人走到终点。

题解：有点奇特的dp，用dp[i][j][k]表示从第k条指令走到(i,j)所需要修改的最小指令数。dp[i][j][k]可以从前一条指令直接执行过来，也可以从dp[i][xx][yy]添加或删除若干条指令后转移过来。枚举所有可能的状态，加入bfs中求解。

#include
#define maxn 55
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,m,sx,sy,ex,ey,len;
char maze[maxn][maxn],s[maxn];
int dp[maxn][maxn][maxn];
int pos[4][2]={1,0,0,1,-1,0,0,-1};
mapmo;
struct node
{
    int x,y;
    int num;
    node(int x=0,int y=0,int num=0):x(x),y(y),num(num){}
};

bool judge(int x,int y)
{
    if(x>0&&x<=n&&y>0&&y<=m&&maze[x][y]!='#')
        return true;
    return false;
}

void init()
{
    mo['D']=0,mo['R']=1;
    mo['U']=2,mo['L']=3;
    for(int i=0;iq;
    q.push(node(sx,sy,0));
    while(!q.empty())
    {
        node now=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            int fx=now.x+pos[i][0];
            int fy=now.y+pos[i][1];
            if(!judge(fx,fy))continue;
            if(dp[fx][fy][now.num]>dp[now.x][now.y][now.num]+1)
            {
                dp[fx][fy][now.num]=dp[now.x][now.y][now.num]+1;
                q.push(node(fx,fy,now.num));
            }
        }
        if(now.numdp[now.x][now.y][now.num]+1)
            {
                dp[now.x][now.y][now.num+1]=dp[now.x][now.y][now.num]+1;
                q.push(node(now.x,now.y,now.num+1));
            }
            int tmp=mo[s[now.num+1]];
            int fx=now.x+pos[tmp][0];
            int fy=now.y+pos[tmp][1];
            if(!judge(fx,fy))fx=now.x,fy=now.y;
            if(dp[fx][fy][now.num+1]>dp[now.x][now.y][now.num])
            {
                dp[fx][fy][now.num+1]=dp[now.x][now.y][now.num];
                q.push(node(fx,fy,now.num+1));
            }
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    init();
    for(int i=1;i<=n;i++)
    {
        scanf("%s",maze[i]+1);
        for(int j=1;j<=m;j++)
        {
            if(maze[i][j]=='R')
                sx=i,sy=j;
            else if(maze[i][j]=='E')
                ex=i,ey=j;
        }
    }
    scanf("%s",s+1);
    len=strlen(s+1);
    dp[sx][sy][0]=0;
    bfs();
    int ans=INF;
    for(int i=0;i<=len;i++)
        ans=min(ans,dp[ex][ey][i]);
    printf("%d\n",ans);
    return 0;
}

C. Cameras

题意：直线上一次有n个点，某一些点已经被标记。问最少再标记多少个点才能使任意连续的r个点中都至少有2个被标记。

题解：先保证最前面的r个，这样对于后面在移动区间的时候，只需要贪心地看第一个和最后一个有没有标记即可。时间复杂度O(N)。

#include
#define maxn 200050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,k,r,a;
bool flag[maxn];

int main()
{
    scanf("%d%d%d",&n,&k,&r);
    memset(flag,0,sizeof(flag));
    for(int i=0;i=1;i--)
    {
        if(num>=2)break;
        if(!flag[i])
        {
            flag[i]=1;
            ans++,num++;
        }
    }
    for(int i=2;i+r-1<=n;i++)
    {
        if(flag[i-1])num--;
        if(flag[i+r-1])num++;
        if(num<2)
        {
            for(int j=(i+r-1);j>=i;j--)
            {
                if(!flag[j])
                {
                    flag[j]=1;
                    ans++,num++;
                    if(num>=2)break;
                }
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

G. Maximum Islands

题意：在地图上有陆地和水域，还有一些不确定区域可能是陆地也可能是水域。问最多可能有多少个陆地连通块。

题解：为了保证连通块数目最大， 我们尽量使连通块的大小为1，首先将所有与已知的陆地相连的未知区域全部标记为水。考虑到不确定区域的陆地一定与水相邻，于是在所有相邻的未知区域之间连边，建立一个新图，答案就是原有的陆地数目加上新图的最大独立集。

#include
#define maxn 2500
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,m,id;
char g[maxn][maxn];
bool vis[maxn],flag[maxn][maxn];
int linker[maxn];
int pos[4][2]={1,0,0,1,-1,0,0,-1};
map< pair,int >mo;
vectorv[maxn];

bool judge(int x,int y)
{
    if(x>=0&&y>=0&&x

H. Paint

题意：给出一些区间，求这些区间两两不相交所能覆盖区域的最大值。

题解：先排序，排序时先按照右端点升序，再按照左端点升序。然后就是一个线性结构上的DP。

#include
#define maxn 200050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int k;
ll dp[maxn],n;
struct node
{
    ll l,r;
    bool friend operator < (const node a,const node b)
    {
        if(a.r==b.r)return a.l>b.l;
        return a.rb?a:b;}

int main()
{
    scanf("%I64d%d",&n,&k);
    for(int i=1;i<=k;i++)
    {
        scanf("%I64d%I64d",&e[i].l,&e[i].r);
    }
    sort(e+1,e+k+1);
    for(int i=1;i<=k;i++)
    {
        int tmp=lower_bound(e+1,e+k+1,e[i],cmp)-e-1;
        dp[i]=Max(dp[i-1],dp[tmp]+e[i].r-e[i].l+1);
    }
    printf("%I64d\n",n-dp[k]);
    return 0;
}

I. Postman

题意：数轴上有一些点，每个点有若干信件需要派送。邮递员在原点处，每次只能携带一定数目的信件。问邮递员所需要走的最小的距离。

题解：将正半轴与负半轴分开处理，贪心地送信件，每次都优先送最远的一个点。

#include
#define maxn 2050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n;
ll k,xa;
struct node
{
    bool flag;
    ll x,m;
    bool friend operator < (const node a,const node b)
    {
        return a.x < b.x;
    }
}e[maxn];

int main()
{
    scanf("%d%I64d",&n,&k);
    for(int i=0;iq;
    while(!q.empty())q.pop();
    for(int i=0;i

J. Shopping

题意：有一些商品和一些顾客，每位顾客都只会在某一个连续的商品区间内购买，并且会依次购买所能购买的最大数目商品。商品数目无限，求每位顾客最终剩下的钱数。

题解：考虑到取模的性质，初始时有x元则最多只会购买log(x)次。预处理出区间最小值，每次购买的时候都二分地找出当前购买区间内第一个可以购买的商品并取模。

#include
#define maxn 200050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,q,l,r;
ll a[maxn],v;
ll dp[maxn][23];
ll Min(ll a,ll b){return av)return v;
        while(lxr)return v;
    }
    return v;
}

int main()
{
    scanf("%d%d",&n,&q);
    for(int i=0;i

K. Tournament Wins

题意：有2^k人淘汰赛，你的能力排第r，问你能够赢下的比赛的场数的期望是多少。

题解：F(i)为至少i场的概率，G(i)为只赢i场的概率， 则Ans=G(1)+2G(2)+...+KG(K)=F(1)+F(2)+...F(K)

推导可得F(i)=C(2^i-1,2^k-r)/C(2^i-1,2^k-1)。

#include
#define maxn 1200000
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int k,r,n;
double pre[maxn];

void init()
{
    pre[1]=0;
    for(int i=2;i<=(1<

L. Windy Path

题意：给出n个点和n-2个操作，求这些点的一个排列，使得如果第i个操作是L，i,i+1,i+2点必须逆时针，否则顺时针。

题解：一定有解。首先我们选定左下的点为第一个点。它在点集凸包上有两个相邻的点。把凸包内作为点的朝向，如果当前指令要求是L即逆时针的话，下一个点是当前点的当前凸包右相邻点。反之是左相邻点。每次要走的点都是当前未走过的点。

#include
#define maxn 105
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,ans[maxn];
char s[maxn];
struct node
{
    int x,y;
    node(int x=0,int y=0):x(x),y(y){}
}e[maxn];
bool operator < (node a,node b)
{
    if(a.x==b.x)return a.y