Codeforces Round #192 (Div. 2) 解题报告 //缺E

---------------

A. Cakeminator

rXc的蛋糕中有一些邪恶的草莓，如果某一行或某一列没有草莓我们可以吃掉这一排。

问最多能吃多少蛋糕。

----

直接暴力寻找空行空列即可。

#include <iostream>
#include <cstring>

using namespace std;

const int maxn=21;

char s[maxn][maxn];
bool v[maxn][maxn];
int r,c;

int main()
{
    memset(v,0,sizeof(v));
    cin>>r>>c;
    for (int i=1;i<=r;i++)
        cin>>(s[i]+1);
    for (int i=1;i<=r;i++)
    {
        bool flag=true;
        for (int k=1;k<=c;k++)
        {
            if (s[i][k]=='S')
            {
                flag=false;
                break;
            }
        }
        if (flag)
        {
            for (int k=1;k<=c;k++) v[i][k]=true;
        }
    }
    for (int j=1;j<=c;j++)
    {
        bool flag=true;
        for (int k=1;k<=r;k++)
        {
            if (s[k][j]=='S')
            {
                flag=false;
                break;
            }
        }
        if (flag)
        {
            for (int k=1;k<=r;k++) v[k][j]=true;
        }
    }
    int ans=0;
    for (int i=1;i<=r;i++)
    {
        for (int j=1;j<=c;j++)
        {
            if (v[i][j]) ans++;
        }
    }
    cout<<ans<<endl;
    return 0;
}

---------------

B. Road Construction

有n个城市，建造一些双向道路使任意一个城市到其他城市的路径不超过2。

有m条路不能建造。求出一个可能的建造方案。

----

观察发现，一个合理的方案是一棵只有叶子节点的深度为1的树。

所以只要枚举根节点，判断是否能建造出所有的边即可。

#include <iostream>
#include <cstring>

using namespace std;

const int maxn=1111;

bool dis[maxn][maxn];
int n,m;

int main()
{
    memset(dis,0,sizeof(dis));
    cin>>n>>m;
    for (int i=1;i<=m;i++)
    {
        int x,y;
        cin>>x>>y;
        dis[x][y]=true;
        dis[y][x]=true;
    }
    for (int rt=1;rt<=n;rt++)
    {
        bool flag=true;
        for (int i=1;i<=n;i++)
        {
            if (dis[rt][i])
            {
                flag=false;
                break;
            }
        }
        if (flag)
        {
            cout<<n-1<<endl;
            for (int i=1;i<=n;i++)
            {
                if (i!=rt)
                {
                    cout<<i<<" "<<rt<<endl;
                }
            }
            break;
        }
    }
    return 0;
}

---------------

C. Purification

在一个nXn的矩阵里有一些邪恶需要净化，每次选择一个点，该点所在的行和列包括自身都将被净化。

有一些点不能被选择。要求选择的点最小。输出一种合理的选择方案。

----

分析知，至少每一行都选择一个点，或每一列都选择一个点才能净化所有的格子。

枚举每一行，选择一个能选择的点，存入答案序列中。

如果有一行没有点可以选择，枚举每一列，选择一个能选择的点，存入序列。

若有一列没有可以选择的点，则输出-1。

若有解，则输出答案。

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

const int maxn=111;

struct POINT{
    int x;
    int y;
    POINT(int a,int b):x(a),y(b){}
};
vector<POINT>ans;
char s[maxn][maxn];
int n;

int main()
{
    bool ok;
    bool flag;
    ans.clear();
    cin>>n;
    for (int i=1;i<=n;i++) cin>>(s[i]+1);
    //bool ret=dfs(1);
    flag=true;
    for (int i=1;i<=n;i++)
    {
        ok=false;
        for (int j=1;j<=n;j++)
        {
            if (s[i][j]=='.')
            {
                ans.push_back(POINT(i,j));
                ok=true;
                break;
            }
        }
        if (!ok)
        {
            flag=false;
            break;
        }
    }
    if (!flag)
    {
        ans.clear();
        flag=true;
        for (int j=1;j<=n;j++)
        {
            ok=false;
            for (int i=1;i<=n;i++)
            {
                if (s[i][j]=='.')
                {
                    ans.push_back(POINT(i,j));
                    ok=true;
                    break;
                }
            }
            if (!ok)
            {
                flag=false;
                break;
            }
        }
    }
    if (!flag) cout<<"-1"<<endl;
    else
    {
        //cout<<ans.size()<<endl;
        for (int i=0;i<ans.size();i++)
        {
            cout<<ans[i].x<<" "<<ans[i].y<<endl;
        }
    }
    return 0;
}

---------------

D. Biridian Forest
在一个rXc的矩阵里有树、空地或数量在1-9之间的敌人。

有一个门和一个起点，从起点出发找一条路径到终点。

玩家和敌人每回合都能上下左右移动一个格子，回合结束后发生战斗。

聪明的敌人会想办法与你相遇并发生战斗，问最小可能的战斗数。

即使到达了终点也要与同时到达的敌人发生战斗。

----

先找出一条路再判断是否能与敌人发生战斗必然是不可行的。

可以发现，到达终点的时间小于等于玩家的敌人必然会发生战斗。（接近路径或者直接到终点守着-_-#）

所以求出所有人到终点的距离再计算答案即可。

即终点到所有人的距离。。。一次广搜解决。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;
const int direct[4][2]={ {0,1},{1,0},{0,-1},{-1,0} };
const int INF=1e9+7;
struct POINT{
    int x;
    int y;
    int dp;
    POINT(int a=0,int b=0,int c=0):x(a),y(b),dp(c){}
};
char s[1111][1111];
int r,c,len;
int ret;
POINT door,start;

bool check(POINT p)
{
    if (p.x>=0&&p.x<r&&p.y>=0&&p.y<c) return true;
    return false;
}
vector<int>ans;
vector<int>num;

void bfs(POINT pin)
{
    POINT p,tmp;
    bool vis[1111][1111];
    queue<POINT>que;
    memset(vis,0,sizeof(vis));
    while (!que.empty()) que.pop();
    pin.dp=0;
    que.push(pin);
    vis[pin.x][pin.y]=true;
    while (!que.empty())
    {
        tmp=que.front();
        que.pop();
        for (int i=0;i<4;i++)
        {
            p.x=tmp.x+direct[i][0];
            p.y=tmp.y+direct[i][1];
            p.dp=tmp.dp+1;
            if (check(p)&&!vis[p.x][p.y]&&s[p.x][p.y]!='T')
            {
                vis[p.x][p.y]=true;
                que.push(p);
                if ( s[p.x][p.y]>='1'&&s[p.x][p.y]<='9' )
                {
                    ans.push_back(p.dp);
                    num.push_back(s[p.x][p.y]-'0');
                }
                if ( s[p.x][p.y]=='S' ) len=p.dp;
            }
        }
    }
}

int main()
{
    ans.clear();
    num.clear();
    ret=0;
    len=INF;
    cin>>r>>c;
    for (int i=0;i<r;i++) cin>>s[i];
    for (int i=0;i<r;i++)
    {
        for (int j=0;j<c;j++)
        {
            if (s[i][j]=='S')
            {
                start.x=i;
                start.y=j;
                start.dp=0;
            }
            if (s[i][j]=='E')
            {
                door.x=i;
                door.y=j;
                door.dp=0;
            }
        }
    }
    bfs(door);
    for (int i=0;i<ans.size();i++)
    {
        if (ans[i]<=len) ret+=num[i];
    }
    cout<<ret<<endl;
    return 0;
}

---------------

---------------