C++博客-止于自娱-随笔分类-搜索

USACO 3.4 Raucous Rockers

YZY — Sat, 11 Jul 2009 03:48:00 GMT

一开始把题意理解错了，以为刻在同一张光盘上的歌曲的时间顺序不变就可以了。
事实上不仅同光盘上的歌曲写入时间要按顺序，前一张光盘上的歌曲不能比后一张歌曲写入时间要晚。

数据量比较少，用回溯法，dp也行。

#include <iostream>
#include <fstream>

using namespace std;

ifstream fin("rockers.in");
ofstream fout("rockers.out");

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int capacity[20];;
int songs[20];
int song_num,disk_num;

int res = 0;
int cur;

void backtracing(int depth,int last)
{
    if(depth==song_num){
        if(cur>res){
            res = cur;
        }
        return;
    }

    //如果后面所有的歌曲都加上还比最优值小，剪枝
    if(cur+song_num-depth<=res)
       return;

    for(int i=last;i<disk_num;++i){
         //如果当前歌曲需要刻录，那只需刻在第一张能装得下的光盘上。
        if( capacity[i]>=songs[depth]){
            cur++;
            capacity[i]-=songs[depth];
            backtracing(depth+1,i);
            capacity[i]+=songs[depth];
            cur--;
            break;
        }
    }

    // 不刻当前歌曲
    backtracing(depth+1,last);

}

void solve()
{
    int c;
    in>>song_num>>c>>disk_num;

    for(int i=0;i<song_num;++i)
        in>>songs[i];

    for(int i=0;i<disk_num;++i)
        capacity[i] = c;

    backtracing(0,0);

    out<<res<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-11 11:48 发表评论

USACO 3.2 Magic Squares

YZY — Mon, 06 Jul 2009 12:01:00 GMT

BFS搜索题。代码写的比较乱，用一个set来存储已经访问过的结点。analysis中的标程有不少可以学习的地方，如几个操作的变换，用转换数组来写，代码清晰明了，encode方法就省去了set。我通过保存整个树来输出解，标程通过反向操作，来输出解，做法很巧妙。

#include <iostream>
#include <fstream>
#include <set>
#include <queue>

using namespace std;

ifstream fin("msquare.in");
ofstream fout("msquare.out");

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int final[8];
set<int>visited;
char result[8*7*6*5*4*3*2*1+1];

struct queue_node{
    int current[8];
    queue_node *parent;
    char op;
};

void op(int *current,char c)
{
    int tmp;
    switch(c){
        case 'A':
            for(int i=0;i<4;++i)
                swap(current[i],current[7-i]);
            break;
        case 'B':
            tmp = current[3];
            for(int i=3;i>=1;--i)
                current[i] = current[i-1];
            current[0] = tmp;
            tmp = current[4];
            for(int i=4;i<=6;++i)
                current[i] = current[i+1];
            current[7] = tmp;
            break;
        case 'C':
            tmp = current[6];
            current[6] = current[5];
            current[5] = current[2];
            current[2] = current[1];
            current[1] = tmp;
            break;
    }
}

int cur_value(int *cur)
{
    int res = 0;
    for(int i=0;i<8;++i){
        res*=10;
        res+=cur[i];
    }

    return res;
}

void solve()
{
    for(int i=0;i<8;++i){
        in>>final[i];
    }

    queue<queue_node*> q;
    queue_node *node = new queue_node;
    for(int i=0;i<8;++i)
        node->current[i] = i+1;

    node->parent = NULL;

    q.push(node);

    while( !q.empty() ){
        queue_node *node = q.front();
        q.pop();

        int cur = cur_value(node->current);
        if( visited.find( cur) != visited.end())
            continue;
        visited.insert(cur);

        bool ok = true;
        for(int i=0;i<8;++i){
            if(node->current[i]!=final[i]){
                ok = false;
                break;
            }
        }

        if(ok){
            int i = 0;
            while(node->parent!=NULL){
                result[i++] = node->op;
                node=node->parent;
            }

            if(i==0){
                out<<0<<endl<<endl;
                exit(0);
            }

            out<<i<<endl;

            int j;
            i--;
            for(j=0;i>=0;i--,j++){
                out<<result[i];
                if(j%60==59) out<<endl;
            }

            if(j%60!=0)
                out<<endl;

            exit(0);
        }

        for(char c='A';c<='C';++c){
            queue_node * n = new queue_node;
            memcpy(n->current,node->current,sizeof(node->current));
            op(n->current,c);
            n->op = c;
            n->parent = node;
            q.push(n);
        }
    }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-06 20:01 发表评论

USACO 2.4 Cow Tours

YZY — Sat, 27 Jun 2009 14:10:00 GMT

这题综合了dfs,floyd算法。

首先用 floyd计算出两两之间的最短路径。然后用dfs将图着色。对每两两不同颜色的结点，我们把它们相连，然后看产生的图的直径的大小。
直径的大小只可能仍为原两连通图直径之一，或者是包括新添加的路径所产生的最长路径，取这三者中的最大值。新路径产生的最长路径只可能是两点的距离加上两点到其他点的最长距离。最开始的时候只考虑了新添加的路径，没考虑原直径会比新路径大的情况，wa了n次。。

#include <iostream>
#include <fstream>

#include <cfloat>
#include <cmath>

using namespace std;

ifstream fin("cowtour.in");
ofstream fout("cowtour.out");

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

double path[150][150];

char graph[150][150];

int x[150];
int y[150];

int n;

int color[150];

double diameter[150];
double maxPath[150];

void floyd()
{
    for(int k=0;k<n;++k)
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j){
                if(i!=j){
                    path[i][j]=min(path[i][j],path[i][k]+path[k][j]);
                }
            }
}

void make_color(int i,int c)
{
    if( color[i]!=0 )
        return;

    color[i] = c;

    for(int j=0;j<n;++j){
        if(color[j]==0&&graph[i][j])
            make_color(j,c);
    }
}

void solve()
{
    in>>n;

    for(int i=0;i<n;++i){
        in>>x[i]>>y[i];
    }

    for(int i=0;i<n;++i){
        string s;
        in>>s;
        for(int j=0;j<n;++j){
            graph[i][j]=s[j]-'0';
            if(graph[i][j]){
                path[i][j] = sqrt( (x[i]-x[j])*(x[i]-x[j])
                    +(y[i]-y[j])*(y[i]-y[j]) );
            }else{
                path[i][j] = DBL_MAX/4;
            }
        }
    }

    floyd();

    int c = 0;
    for(int i=0;i<n;++i)
        if(color[i]==0)
            make_color(i,++c);

    for(int i=0;i<n;++i){
        maxPath[i] = 0;
        for(int j=0;j<n;++j){
            if(i!=j&&color[i]==color[j]){
                maxPath[i] = max(maxPath[i],path[i][j]);
            }
        }

        diameter[color[i]] = max(diameter[color[i]],maxPath[i]);
    }

    double dia = DBL_MAX;

    for(int i=0;i<n;++i)
        for(int j=i+1;j<n;++j){

            if(color[i]==color[j]) continue;

            double d1 = 0;
            for(int p=0;p<n;++p){
                if(i!=p&&color[i]==color[p])
                    d1 = max(d1,path[i][p]);
            }

            double d2 = 0;
            for(int p=0;p<n;++p){
                if(j!=p&&color[j]==color[p])
                    d2 = max(d2,path[j][p]);
            }

            double dist = sqrt( (x[i]-x[j])*(x[i]-x[j])+
                    (y[i]-y[j])*(y[i]-y[j]) );

            dia = min(dia,max(d1+d2+dist,max(diameter[color[i]],diameter[color[j]])) );
        }

    out.setf(ios::fixed,ios::floatfield);
    out.precision(6);
    out<<dia<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-06-27 22:10 发表评论

USACO 2.4 Overfencing

YZY — Fri, 26 Jun 2009 14:25:00 GMT

找出两个迷宫的出口，然后分别进行dfs，求出到每一个点的最短距离。
然后对每一个点，求到最短的那个出口的距离，然后再求这个值的最大值即可。
找出口写得比较繁琐。

#include <iostream>
#include <fstream>
#include <queue>

using namespace std;

ifstream fin("maze1.in");
ofstream fout("maze1.out");

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

char maze[2*100+1][2*38+1];

bool visited[100][38];

int shortest1[100][38];
int shortest2[100][38];

bool get_first;
int exit1r,exit1c;
int exit2r,exit2c;
int w,h;

struct queue_node{
    int i,j,depth;
    queue_node(int i,int j,int depth){
        this->i = i;
        this->j = j;
        this->depth = depth;
    }
};

void bfs(int i,int j,int shortest[100][38])
{
    queue<queue_node>q;

    q.push(queue_node(i,j,1));

    while(!q.empty()){

        queue_node node = q.front();
        q.pop();

        if(visited[node.i][node.j])
            continue;

        visited[node.i][node.j] = true;

        shortest[node.i][node.j] = node.depth;

        if(node.i!=0&&maze[2*node.i][2*node.j+1]==' '){
            q.push(queue_node(node.i-1,node.j,node.depth+1));
        }
        if(node.i!=h-1&&maze[2*node.i+2][2*node.j+1]==' '){
            q.push(queue_node(node.i+1,node.j,node.depth+1));
        }
        if(node.j!=0&&maze[2*node.i+1][2*node.j]==' '){
            q.push(queue_node(node.i,node.j-1,node.depth+1));
        }
        if(node.j!=w-1&&maze[2*node.i+1][2*node.j+2]==' '){
            q.push(queue_node(node.i,node.j+1,node.depth+1));
        }
    }
}

void solve()
{
    in>>w>>h;

    for(int i=0;i<2*h+1;++i)
        for(int j=0;j<2*w+1;++j){

            do{
            in.get(maze[i][j]);
            }while(maze[i][j]=='\n');

            if((i==0||i==2*h||j==0||j==2*w)&&maze[i][j]==' '){
                if(!get_first){
                    if(i==2*h)
                        exit1r = h-1;
                    else
                        exit1r = i/2;
                    if(j==2*w)
                        exit1c = w-1;
                    else
                        exit1c = j/2;
                    get_first = true;
                }else{
                    if(i==2*h)
                        exit2r = h-1;
                    else
                        exit2r = i/2;
                    if(j==2*w)
                        exit2c = w-1;
                    else
                        exit2c = j/2;
                }
            }
        }

    memset(visited,0,sizeof(visited));
    bfs(exit1r,exit1c,shortest1);
    memset(visited,0,sizeof(visited));
    bfs(exit2r,exit2c,shortest2);

    int res = INT_MIN;

    for(int i=0;i<h;++i)
     for(int j=0;j<w;++j){
         res = max(res, min(shortest1[i][j],shortest2[i][j]) );
     }

    out<<res<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-06-26 22:25 发表评论