久久久久国产精品麻豆AR影院,久久人人爽人人爽人人av东京热,久久精品无码午夜福利理论片

USACO 3.4 Raucous Rockers

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

一开始把题意理解错了�Q�以为刻在同一张光盘上的歌曲的旉��序不变��可以了�?br />事实上不仅同光盘上的歌曲写入旉��要按��序�Q�前一张光盘上的歌曲不能比后一张歌曲写入时间要晚�?br />
数据量比较少�Q�用回溯法，dp也行�?br />

#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;
    }

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

    for(int i=last;i<disk_num;++i){
         //如果当前歌曲需要刻录，那只需��d��W�一张能装得下的光盘上�?br />        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搜烦题。代码写的比较�ؕ�Q�用一个set来存储已�l�访问过的结炏V��analysis中的标程有不��可以学习的地方�Q�如几个操作的变换，用�{换数�l�来写，代码清晰明了�Q�encode�Ҏ(gu��)��q��M��set。我通过保存整个树来输出解，标程通过反向操作�Q�来输出解，做法很��y妙�?br />

#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

�q�题�l�合了dfs,floyd��法�?br />
首先�?floyd计算��Z��两之间的最短�\径。然后用dfs��图着艌Ӏ�对每两两不同颜色的�l�点�Q�我们把它们相连�Q�然后看产生的图的直径的大小�?br />直径的大��只可能仍�ؓ原两�q�通图直径之一�Q�或者是包括新添加的路径所产生的最长�\径，取这三者中的最大倹{��新路径产生的最长�\径只可能是两点的距离加上两点到其他点的最长距��R��最开始的时候只考虑了新��d��的�\径，没考虑原直径会比新路径大的情况�Q�wa了n�ơ。�?br />

#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

扑և�两个�q�宫的出口，然后分别�q�行dfs�Q�求出到每一个点的最短距��R�?br />然后�Ҏ(gu��)��一个点�Q�求到最短的那个出口的距��，然后再求�q�个值的最大值即可�?br />扑և�口写得比较繁琐�?br />

#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 发表评论