Codeforces Round #302 (Div. 2)

A. Set of Strings

　　题意：能否把一个字符串划分为n段，且每段第一个字母都不相同？

　　思路：判断字符串中出现的字符种数，然后划分即可。

#include<iostream>
#include<set>
#include<cstdio>
#include<cstring>
using namespace std;
char s[110];
set<char>st;
int main()
{
    int n;
    scanf("%d%s", &n,s);
    int len = strlen(s);
    for (int i = 0; i < len; i++)
    {
        if (!st.count(s[i]))st.insert(s[i]);
    }
    if (st.size() < n) printf("NO\n");
    else
    {
        st.clear();
        printf("YES\n");
        int cur = 0;
        while (n--)
        {
            st.insert(s[cur]);
            while (cur<len&&st.count(s[cur]))
            {
                printf("%c", s[cur++]);
            }
            if (n == 0)
            {
                while(cur<len) printf("%c", s[cur++]); 
            }
            printf("\n");
        }
    }
    return 0;
}

B. Sea and Islands

　　题意：n*n的网格里都是水，现在需要填沙造出k个陆地，两两之间有边相邻的看成一片陆地。

　　思路：讨论奇偶。

#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
    int n, k;
    scanf("%d%d", &n, &k);
    int maxs = n / 2 * n + n % 2 * (n + 1) / 2;
    if (k > maxs)printf("NO\n");
    else
    {
        printf("YES\n");
        for (int i = 0; i < n; i++)
        {
            int st;
            if (i % 2==0) st = 0;
            else st = 1;
            for (int j=0; j < n; j++)
            {
                if ((j - st) % 2 == 0&&k>0) printf("L"),k--;
                else printf("S");
            }
            printf("\n");
        }
    }
    return 0;
}

C. Writing Code

　　题意：有n个程序员，现在需要合作完成m行的代码，要求最多只有b个bug,求总方案数？

　　思路：dp[i][j][k]:表示前i个程序员一起写j行代码bug数为k的方案数.采用滚动数组优化。

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 510;
const int maxm = 510;
const int maxb = 510;
int dp[2][maxm][maxb];//[i][j][k]表示前i个程序员一起写j行代码bug数为k的方案数
int bugs[maxn];
int main()
{
    int n, m, b, mod;
    scanf("%d%d%d%d", &n, &m, &b, &mod);
    for (int i = 1; i <= n; i++) scanf("%d", bugs + i);
    dp[0][0][0] = dp[1][0][0] = 1;
    int pre, now;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            for (int k =0; k <= b; k++)
            {
                pre = ((i - 1) & 1),now=(i&1);
                if (k >= bugs[i]) dp[now][j][k] = (dp[pre][j][k] + dp[now][j - 1][k - bugs[i]]) % mod;
                else dp[now][j][k] = dp[pre][j][k];
            }
        }
    }
    int ans = 0;
    for (int i = 0; i <= b; i++) ans = (ans + dp[now][m][i]) % mod;
    printf("%d\n",ans);
    return 0;
}

 D. Destroying Roads

　　题意：有n个点，m条无向边。在保证s1到t1不超过l1小时、s2到t2不超过l2小时(每走一条边花费1小时)的情况下，求最多可以删去多少条边？

　　思路：求出每两点之间的最短距离，然后2层循环枚举重复的路径。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
const int maxn = 3010;
struct edge
{
    int next, to;
    edge(int tt=0,int nn=0):to(tt),next(nn){}
};
edge Edge[maxn*maxn];
int Head[maxn], totedge;
void addedge(int from, int to)
{
    Edge[totedge] = edge(to, Head[from]);
    Head[from] = totedge++;
    Edge[totedge] = edge(from, Head[to]);
    Head[to] = totedge++;
}
int dis[maxn][maxn];
bool vis[maxn];
const int INF = 0x3f3f3f3f;
int n, m;
void SPFA(int st)
{
    for (int i = 0; i <= n; i++) dis[st][i] = INF;
    dis[st][st] = 0;
    vis[st] = true;
    queue<int>q;
    q.push(st);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = Head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (dis[st][v] > dis[st][u] + 1)
            {
                dis[st][v] = dis[st][u] + 1;
                if (!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
}
int main()
{
    scanf("%d%d", &n, &m);
    memset(Head, -1, sizeof(Head));
    totedge = 0;
    for (int i = 1; i <= m; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        addedge(u, v);
    }
    int s1, d1, l1, s2, d2, l2;
    scanf("%d%d%d%d%d%d", &s1, &d1, &l1, &s2, &d2, &l2);
    for (int i = 1; i <= n; i++) SPFA(i);
    if (dis[s1][d1] > l1 || dis[s2][d2] > l2) printf("-1\n");
    else
    {
        int minnum = dis[s1][d1] + dis[s2][d2];
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= i; j++)
            {
                if (dis[s1][i] + dis[i][j] + dis[j][d1] <= l1 && dis[s2][i] + dis[i][j] + dis[j][d2] <= l2)
                {
                    minnum = min(minnum, dis[s1][i] + dis[i][j] + dis[j][d1] + dis[s2][i] + dis[j][d2]);
                }
                if (dis[s1][i] + dis[i][j] + dis[j][d1] <= l1 && dis[s2][j] + dis[j][i] + dis[i][d2] <= l2)
                {
                    minnum = min(minnum, dis[s1][i] + dis[i][j] + dis[j][d1] + dis[s2][j] + dis[i][d2]);
                }
                if (dis[s1][j] + dis[j][i] + dis[i][d1] <= l1 && dis[s2][i] + dis[i][j] + dis[j][d2] <= l2)
                {
                    minnum = min(minnum, dis[s1][j] + dis[j][i] + dis[i][d1] + dis[s2][i] + dis[j][d2]);
                }
                if (dis[s1][j] + dis[j][i] + dis[i][d1] <= l1 && dis[s2][j] + dis[j][i] + dis[i][d2] <= l2)
                {
                    minnum = min(minnum, dis[s1][j] + dis[j][i] + dis[i][d1] + dis[s2][j] + dis[i][d2]);
                }
            }
        }
        printf("%d\n", m - minnum);
    }
    return 0;
}

 E. Remembering Strings

　　题意：有n个字符串，每个字符串m位，要使得每个字符串存在一个位置i上的字符唯一(其他字符串该位上的字符与该字符串不同，称为易记字符串)，你可以将某个字符串某位替换成任意字符，给出每个字符串每位替换的代价，求最小代价？

　　思路：将n个字符串各自是否为易记标记为0/1，则我们可以进行状态压缩，对每个当前的状态，找到最低位的0(表示该字符串进行转换，其余高位的0无需转换)，按照以下策略进行替换：如果该位唯一，则dp[i | (1 << j)] = dp[i]，否则考虑2种方案：第一种方案，直接让该位字符唯一——dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + cost[j][k])；第二种方案，找到所有和该字符串该位字符一样的所有字符串，除去代价最大的，其他字符串进行转换——dp[i | tmp] = min(dp[i | tmp], dp[i] + sumc - maxc)。

　　初始化为-1时需要考虑当前状态在此前是否已被转换到，没有则跳过；初始化为INF则不用考虑。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
char str[25][25];
int cost[25][25];
const int maxc = 1 << 20;//最大状态数
int dp[maxc];
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) scanf("%s", str + i);
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++) scanf("%d", &cost[i][j]);
    }
    int total = (1 << n) - 1;//最终状态为111...11,n个1表示n个字符串都为易记
    memset(dp, -1, sizeof(dp));
    dp[0] = 0;
    for (int i = 0; i <total; i++)//枚举状态
    {
        if (dp[i] == -1) continue;//该状态没有被转移到，跳过
        int j = 0;
        while (((i >> j) & 1) == 1) j++;//找到该状态中为非易记的字符串进行状态转移
        for (int k = 0; k < m; k++)
        {//让该字符串第k位的字符唯一
            int cnt = 0, sumc = 0, maxc = 0, tmp = 0;
            for (int z = 0; z < n; z++)
            {
                if (str[z][k] == str[j][k])
                {
                    cnt++;
                    sumc += cost[z][k];//总代价
                    maxc = max(maxc, cost[z][k]);//最大代价
                    tmp |= (1 << z);//所有和该字符串该位一样的字符串为易记时的状态
                }
            }
            if (cnt == 1)//如果该位字符本就唯一
            {
                if (dp[i | (1 << j)] == -1)dp[i | (1 << j)] = dp[i];
                else dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i]);
            }
            else//否则
            {
                //第一种方案，直接让该位字符唯一
                if (dp[i | (1 << j)] == -1) dp[i | (1 << j)] = dp[i] + cost[j][k];
                else dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + cost[j][k]);
                //第二种方案，找到所有和该字符串该位字符一样的所有字符串，除去代价最大的，其他字符串进行转换
                if (dp[i | tmp] == -1) dp[i | tmp] = dp[i] + sumc - maxc;
                else dp[i | tmp] = min(dp[i | tmp], dp[i] + sumc - maxc);
            }
        }
    }
    printf("%d\n", dp[total]);
    return 0;
}