2017/9/23周测（CF2016-2017 ACM-ICPC Pacific Northwest Regional Contest (Div. 2)）

A题（最长上升子序列）
思路还是很好找的，就是求这一串数的最长上升子序列，然后找出最大的就可以了，最长上升子序列n²的dp就是dp的值存的是以这个数为结尾的最长上升子序列，所以每一次求一个值得时候都要先遍历一遍前面的，所以就是n²的复杂度

#include<iostream>
using namespace std;
#include<algorithm>
#include<string.h>

int main()
{
    char s[55];
    int dp[55];
    while(cin>>s)
    {
        int i,j;
        int len=strlen(s);
        for(i=0;i<len;i++)
            dp[i]=1;
        for(i=0;i<len;i++)
        {
            for(j=0;j<i;j++)//以第i个数结尾
            {
                if(s[i]>s[j])
                dp[i]=max(dp[j]+1,dp[i]);
            }
        }
        int maxnum=0;
        for(i=0;i<len;i++)
            maxnum=max(maxnum,dp[i]);
        printf("%d\n",26-maxnum);
    }
    return 0;
}

H题（dfs）
这个题就深深地暴露出我对dfs的理解基本为0，题意就是输出联通块的个数，那么怎么处理‘C’就是一个问题，dfs在主函数中扫描就是遇到一个符合题意的（本题为‘L’）就开始扫描，但是遇到的如果是‘C’就不管它，然后在dfs的子函数中，就是遇到的‘C’就当做‘L’。

#include<iostream>
using namespace std;
#include<algorithm>
#include<string.h>
#include<vector>

int n,m;
char map[55][55];
bool vis[55][55];
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int num;

void dfs(int i,int j)
{
    if(i<0||i>=n||j<0||j>=m)
        return;
    num++;
    vis[i][j]=1;
    int k;
    for(k=0;k<4;k++)
    {
        int x=i+dir[k][0];
        int y=j+dir[k][1];
        if(x<0||x>=n||y<0||y>=m)
            continue;
        if((map[x][y]=='L'||map[x][y]=='C')&&!vis[x][y])
            dfs(x,y);
    }
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        vector<int>a;
        memset(vis,0,sizeof(vis));
        int i,j;
        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
                cin>>map[i][j];
        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
            {
                if(map[i][j]=='L'&&!vis[i][j])
                {
                    num=0;
                    dfs(i,j);
                    a.push_back(num);
                }
            }

        printf("%d\n",a.size());
    }
    return 0;
}

让我们从头再理一遍dfs的思路，基本的就是一张map，一个vis数组，主函数中其实是在找新的连通块，然后dfs函数的一大作用就是把能够连起来的连通块给连起来（标记好）

M题（dp）

M题的意思就是找上升下降序列，其实和最长上升子序列是一样的，不过需要开两个dp数组，一个记录以i元素为上升元素的，一个记录以i元素为下降元素的
看懂样例→5，2 1 3 4 2，最长的上升下降序列就是2 1 3 2或者2 1 4 2

#include<iostream>
using namespace std;
#include<algorithm>
#include<string.h>
#include<vector>

int n;
int num[55];
int dp1[55];//上升 
int dp2[55];//下降 

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        memset(dp1,0,sizeof(dp1));
        memset(dp2,0,sizeof(dp2));
        int i;
        for(i=0;i<n;i++)
            scanf("%d",&num[i]);
        int j;
        for(i=0;i<n;i++)
        {
            for(j=0;j<i;j++)
            {
                if(num[j]>num[i])
                {
                    dp2[i]=max(dp1[j]+1,dp2[i]);
                }
                if(num[j]<num[i])
                {
                    dp1[i]=max(dp2[j]+1,dp1[i]);
                }
            }
        }
        int maxn=-9999999;
        for(i=0;i<n;i++)        
            maxn=max(maxn,dp1[i]);      
        for(i=0;i<n;i++)
            maxn=max(maxn,dp2[i]);  
        cout<<maxn+1<<endl;
    }
    return 0;
}

D题（贪心）
这个题题意其实比较好理解，输入三个数n，k，r，n个房子，k盏灯，连续的r个房子至少要有2盏灯，然后告诉这k个灯的位置，贪心比较好想，当灯数不够的时候，一定要从后面放灯，这样可以尽可能地帮到后面的连续的组合。

#include<iostream>
using namespace std;
#include<algorithm>
#include<string.h>
#include<vector>

bool num[100005];

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

☝这是一份最暴力的代码，超时了。

#include<iostream>
using namespace std;
#include<algorithm>
#include<string.h>
#include<vector>

bool num[100005];

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

        for(i=r+1;i<=n;i++)
        {
            if(num[i-r]==1)
            flag--;
            if(num[i]==1)
            flag++;
            if(flag<2)
            {
                num[i]=1;
                flag++;
                ans++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

☝这是AC的代码，啦啦啦，我自己写的！

这个题大概就是暑假的时候学的一个方法，可以完美地用在这里，最开始的时候先把前r个有几个照相机算出来，然后去掉最左边那个，再向右加一个，然后这两个有没有照相机，相应的加减我现有的照相机的值，始终只有一个值，就是现在的r个房子里有几个照相机，充分利用前面算过的！

J题（贪心）
题意大概就是邮递员要去送信，n个房子，每个房子在xi位置，有mi封信，然后post office在0位置，邮递员每次最多能拿k封信，问把所有的信送完最少需要多少时间。