训练总结 8.4

一、安排

 搜索题，有几道题涉及了一点图论。

二、题目

1、Network Saboteur

 dfs，倒是不复杂，就是有一点点别扭。

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

int n,cnt;
int a[31][31];
bool vis[31];

void dfs(int i,int sum)//sum表示两组间的权值，在i未加入之前
{
    vis[i]=1;
    int num=sum;
    for(int j=1;j<=n;j++)
    {
        if(vis[j])
            num-=a[i][j];//i新加入第一组，j原来是第一组的，--
        else
            num+=a[i][j];//i新加入第一组，j原来是第二组的，++
    }
    if(cnt<num)
        cnt=num;
    if(num>sum)
    {
        for(int k=i+1;k<=n;k++)
        {
            dfs(k,num);
            vis[k]=0;
        }
    }
}

int main()
{
    cnt=-1;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cin>>a[i][j];
        }
    }
    memset(vis,0,sizeof(vis));//都在第二组
    dfs(1,0);
    cout<<cnt<<endl;
    return 0;
}

    }
}

2、Channel Allocation

涂色问题，相邻的不重色，最少需要多少种颜色

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

bool Map[31][31];
int colour[31];
bool vis[31];
int n,m;

int main()
{
    char s,c;
    char str[31];
    int M;
    while(scanf("%d",&n)&&n)
    {
        memset(Map,false,sizeof(Map));
        for(int i=0;i<n;i++)
        {
            scanf("%c%c%s",&s,&c,str);
            for(int j=0;str[j];j++)
            {
                Map[i][str[j]-'A']=true;
            }
        }
        memset(colour,-1,sizeof(colour));
        M=-1;
        for(int i=0;i<n;i++)
        {
            colour[i]=n+1;
            memset(vis,false,sizeof(vis));
            for(int j=0;j<n;j++)
            {
                if(Map[i][j]&&colour[j]!=-1)
                {
                    vis[colour[j]]=true;
                }
            }
            for(int j=1;j<=n;j++)
            {
                if(!vis[j])
                {
                    colour[i]=j;
                    break;
                }
            }
            if(M<colour[i])
            {
                M=colour[i];
            }
        }
        if(M==1)
        {
            printf("1 channel needed.\n");
        }
        else
        {
            cout<<M<<" channels needed."<<endl;
        }
    }
    return 0;
}

3、pots

倒可乐问题的变形

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

int A,B,C;
bool vis[100][100];
bool vis1[100][100];
int enda,endb;

struct Node
{
    int x,y,step;//小杯、大杯中水的体积
};

struct Out
{
    int a,b;
    int num;
}out[100][100];

void bfs()
{
    queue<Node>q;
    Node start,now,next;
    start.x=0;
    start.y=0;
    start.step=0;
    vis[0][0]=1;
    q.push(start);
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==C||now.y==C)
        {
            cout<<now.step<<endl;
            enda=now.x;
            endb=now.y;
            return;
        }
        if(now.x<A&&!vis[A][now.y])
        {
            next.x=A;
            next.y=now.y;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
                out[next.x][next.y].a=now.x;
                out[next.x][next.y].b=now.y;
                out[next.x][next.y].num=1;
                vis1[next.x][next.y]=1;
            }
        }//FILL(A)
        if(now.y<B&&!vis[now.x][B])
        {
            next.x=now.x;
            next.y=B;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
            out[next.x][next.y].a=now.x;
            out[next.x][next.y].b=now.y;
            out[next.x][next.y].num=2;
            vis1[next.x][next.y] = 1;
            }
        }//FILL(B)
        if(now.x>0&&!vis[0][now.y])
        {
            next.x=0;
            next.y=now.y;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
            out[next.x][next.y].a=now.x;
            out[next.x][next.y].b=now.y;
            out[next.x][next.y].num=3;
            vis1[next.x][next.y] = 1;
            }
        }//DROP(A)
        if(now.y>0&&!vis[now.x][0])
        {
            next.x=now.x;
            next.y=0;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
            out[next.x][next.y].a=now.x;
            out[next.x][next.y].b=now.y;
            out[next.x][next.y].num=4;
            vis1[next.x][next.y] = 1;
            }
        }//DROP(B)
        if(now.x+now.y<=B&&!vis[0][now.x+now.y])
        {
            next.x=0;
            next.y=now.x+now.y;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
            out[next.x][next.y].a=now.x;
            out[next.x][next.y].b=now.y;
            out[next.x][next.y].num=5;
            vis1[next.x][next.y]=1;}
        }
        else if(!vis[now.x+now.y-B][B])
        {
            next.x=now.x+now.y-B;
            next.y=B;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
            out[next.x][next.y].a=now.x;
            out[next.x][next.y].b=now.y;
            out[next.x][next.y].num=5;
            vis1[next.x][next.y] =1;}
        }
        if(now.x+now.y<=A&&!vis[now.x+now.y][0])
        {
            next.x=now.x+now.y;
            next.y=0;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
            out[next.x][next.y].a=now.x;
            out[next.x][next.y].b=now.y;
            out[next.x][next.y].num=6;
            vis1[next.x][next.y]=1;}
        }
        else if(!vis[A][now.x+now.y-A])
        {
            next.x=A;
            next.y=now.x+now.y-A;
            next.step=now.step+1;
            q.push(next);
            if(!vis1[next.x][next.y])
            {
            out[next.x][next.y].a=now.x;
            out[next.x][next.y].b=now.y;
            out[next.x][next.y].num=6;
            vis1[next.x][next.y]=1;}
        }
    }
    cout<<"impossible"<<endl;
    return;
}

void dfs(int xx,int yy)
{
   // cout << xx << " " << yy << endl;
    if(xx==0&&yy==0)
        return;
    dfs(out[xx][yy].a,out[xx][yy].b);
    if(out[xx][yy].num==1)cout<<"FILL(1)"<<endl;
    else if(out[xx][yy].num==2)cout<<"FILL(2)"<<endl;
    else if(out[xx][yy].num==3)cout<<"DROP(1)"<<endl;
    else if(out[xx][yy].num==4)cout<<"DROP(2)"<<endl;
    else if(out[xx][yy].num==5)cout<<"POUR(1,2)"<<endl;
    else if(out[xx][yy].num==6)cout<<"POUR(2,1)"<<endl;

}

int main()
{
    cin>>A>>B>>C;
    //if(A>B)
        //swap(A,B);
    memset(vis,0,sizeof(vis));
    memset(vis1,0,sizeof(vis1));
    bfs();
    dfs(enda,endb);
    return 0;
}

这个代码在处理输出路径问题遇到了问题，内存超了。查了一下题解，看了一下如何保存路径。

 

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include<stack>
using namespace std;

struct cup
{
    int x, y;
    int step;
    int flag;//标记操作
    cup *pre;//记录路径
};

queue<cup>Q;
stack<int>R;
int a, b, e;
int vis[101][101]={0};//标记当前状态是否到达过
int ans;

void BFS(int x, int y)
{
    cup c;
    cup t[317];//目前瓶子里剩余的水量
    c.x = 0, c.y = 0;
    c.flag = 0;
    c.pre = NULL;
    c.step = 0;
    Q.push(c);
    vis[x][y] = 1;
    int cnt = -1;
    while(!Q.empty())
    {
        cnt++;
        t[cnt] = Q.front();
        Q.pop();
        for(int i = 1; i <= 6; i++)
        {
            switch(i)
            {
                case 1:                        //fill a
                    c.x = a;
                    c.y = t[cnt].y;
                    c.flag = 1;
                    break;
                case 2:                        //fill b
                    c.x = t[cnt].x;
                    c.y = b;
                    c.flag = 2;
                    break;
                case 3:                        //drop a
                    c.x = 0;
                    c.y = t[cnt].y;
                    c.flag = 3;
                    break;
                case 4:                        //drop b
                    c.x = t[cnt].x;
                    c.y = 0;
                    c.flag = 4;
                    break;
                case 5:                        //pour a to b
                    if(t[cnt].x > b-t[cnt].y)
                    {
                        c.x = t[cnt].x-(b-t[cnt].y);
                        c.y = b;
                    }
                    else
                    {
                        c.x = 0;
                        c.y = t[cnt].y+t[cnt].x;
                    }
                    c.flag = 5;
                    break;
                case 6:                        //pour b to a
                    if(t[cnt].y > a-t[cnt].x)
                    {
                        c.y = t[cnt].y - (a-t[cnt].x);
                        c.x = a;
                    }
                    else
                    {
                        c.x = t[cnt].x+t[cnt].y;
                        c.y = 0;
                    }
                    c.flag = 6;
                    break;
            }
            if(vis[c.x][c.y])
                continue;
            vis[c.x][c.y] = 1;
            c.step = t[cnt].step+1;
            c.pre = &t[cnt];
            if(c.x == e || c.y == e)
            {
                ans = c.step;
                while(c.pre)
                {
                    R.push(c.flag);
                    c = *c.pre;
                }
                return;
            }
            Q.push(c);
        }
    }
}

void print()
{
    while(!R.empty())
    {
        int i = R.top();
        R.pop();
        switch(i)
        {
            case 1:cout<<"FILL(1)"<<endl;break;
            case 2:cout<<"FILL(2)"<<endl;break;
            case 3:cout<<"DROP(1)"<<endl;break;
            case 4:cout<<"DROP(2)"<<endl;break;
            case 5:cout<<"POUR(1,2)"<<endl;break;
            case 6:cout<<"POUR(2,1)"<<endl;break;
        }
    }
}
int main()
{
    cin >>a>>b>>e;
    BFS(0,0);
    if(ans == 0)
        cout<<"impossible"<<endl;
    else
    {
        cout<<ans<<endl;
        print();
    }
    return 0;
}