USACO 2.2Party Lamps

本文介绍了一种通过四个开关控制灯泡状态的问题解决方法。利用深度优先搜索算法(DFS),结合状态压缩技巧,实现了对所有可能状态的有效遍历,并通过优化避免了重复计算。文章详细解释了如何将灯泡分为四类进行操作,最终输出所有可行解。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

meaning:是给4个开关,第一个开关控制所有灯,也就是本来开的变关,本来关的变开,第二个开关控制单数灯,第三个开关控制双数灯,第4个开关控制n%3==1的灯。

给一个n,c,分别表示灯的数量和按下开关的数量,然后再给按c次开关后有哪几个灯是亮的,哪几个灯是不亮的。如果存在满足的可能则输出所有可能,按照0在前面的输出顺序,也就是数组大小的输出顺序,如果不可能则输出IMPOSSIBLE.

the reason of failure:1、范围特例,特殊没考虑按开关为0的可能。

2、题意理解,没注意输出的顺序是要按数组大小而不是按照0的个数从小到大。

3、数据是水过的~

thinking:因为c在16次后的按下和之前是重复的那么大于16的可以%16。然后可以把灯分为4类,因为这4类的灯都是同亮同按的,然后dfs,把所有满足条件放入一个数组,然后O(n^2)的方法比较,找出最大的标记后输出。

/*
ID: me
PROG: lamps
LANG: C++
*/
#include<iostream>
#include <string.h>
#include <stdio.h>
#include <map>
#include <algorithm>
using namespace std;
int q1[5];
int qq[105];
int q2[5],n;
int q3[5];
struct ttt{
int z,a[100];
};
int q5[50][150];
ttt q6[105];
int gg1;
int t1;
bool walked[500];
map<long long,int>ccc;
int fun(){
    int i,j,k;
    for(i=1;i<=4;i++){
           // cout << q3[i] << " " << q1[i] <<endl;
        if(q3[i]==q1[i]||(q3[i]==-1&&q1[i]==0)||q1[i]==-1){
            continue;
        }else{
            //cout <<i << endl;
            return 0;
        }
    }
    int c5=0;
    for(i=1;i<=4;i++){
        if(q3[i]==-1)c5=c5*10+0;
        else c5=c5*10+q3[i];
    }
    if(ccc[c5]!=0){
        return 0;
    }else{
        ccc[c5]=1;
    }
    gg1++;
    q6[gg1].z=gg1;
    for(i=1;i<=n;i++){
        if(i%2==0){
            if(i%3==1){
                if(q3[2]==-1)
                    //cout << 0;
                    q5[gg1][i]=0;     //-1是指没开灯也就是0
                else{
                    q6[gg1].a[i]++;
                    //cout << 1;
                    q5[gg1][i]=1;
                }
                }else{
                if(q3[4]==-1)
                    //cout << 0;
                    q5[gg1][i]=0;     //-1是指没开灯也就是0
                else{
                        q6[gg1].a[i]++;
                //cout << 1;
                    q5[gg1][i]=1;
                }

                }
        }else{
        if(i%3==1){
                if(q3[1]==-1)
                    //cout << 0;
                    q5[gg1][i]=0;     //-1是指没开灯也就是0
                else{
                //cout << 1;
                    q5[gg1][i]=1;
                q6[gg1].a[i]++;}
                }else{
                if(q3[3]==-1)
                    //cout << 0;
                    q5[gg1][i]=0;   //-1是指没开灯也就是0
                else{
                        q6[gg1].a[i]++;
                    //cout << 1;
                    q5[gg1][i]=1;}

                }
        }
    }
    //cout <<endl;
}
int dfs(int x){
    if(x>t1)fun();
    else{
        for(int i=1;i<=4;i++){
            if(i==1){
                q3[2]=-q3[2];
                q3[3]=-q3[3];
                q3[4]=-q3[4];
                q3[1]=-q3[1];
                dfs(x+1);
                q3[2]=-q3[2];
                q3[3]=-q3[3];
                q3[4]=-q3[4];
                q3[1]=-q3[1];
            }else if(i==2){
                q3[4]=-q3[4];
                q3[2]=-q3[2];
                dfs(x+1);
                q3[4]=-q3[4];
                q3[2]=-q3[2];
            }else if(i==3){
                q3[1]=-q3[1];
                q3[3]=-q3[3];
                dfs(x+1);
                q3[3]=-q3[3];
                q3[1]=-q3[1];
            }else if(i==4){
                q3[2]=-q3[2];
                q3[1]=-q3[1];
                dfs(x+1);
                q3[2]=-q3[2];
                q3[1]=-q3[1];
        }
        }
    }
}
int sort1(const ttt *x,const ttt  *y){
    int i;
    int t1,t2;
    for(i=1;i<=n;i++){
            t1=(*(ttt*)x).a[i];
           t2=(*(ttt*)y).a[i];
        if(t1!=t2){
            return t1>t2;
        return 1;
        }
    }
}

int main(){
    freopen("in.txt","r",stdin);
   // freopen("lamps.in","r",stdin);
    //freopen("lamps.out","w",stdout);
    int i,j,k,l,f1,f2,f3,t2,t3;
    int m;
    gg1=0;
    memset(qq,-1,sizeof(qq));
    memset(q1,-1,sizeof(q1));
    memset(q5,0,sizeof(q5));
    memset(q6,0,sizeof(q6));
    memset(walked,0,sizeof(walked));
    for(i=1;i<=4;i++)
        q3[i]=1;
    scanf("%d",&n);
    //ccc.clear;
    cin >> t1; //刚开始,全部都是on
    t1=t1%16;
    while(scanf("%d",&t2)==1&&t2!=-1){
        qq[t2]=0;
    if(t2%2==0){
        if(t2%3==1){
            q1[2]=1;
        }else{
            q1[4]=1;
        }
    }else{
        if(t2%3==1){
            q1[1]=1;
        }else{
            q1[3]=1;
        }
    }
    }
    while(scanf("%d",&t3)==1&&t3!=-1){
        qq[t3]=1;
    if(t3%2==0){
        if(t3%3==1){
            q1[2]=0;
        }else{
            q1[4]=0;
        }
    }else{
        if(t3%3==1){
            q1[1]=0;
        }else{
            q1[3]=0;
        }
    }
    }
    for(i=1;i<=4;i++)
        q2[i]=1;
    dfs(1);
    t3=1;
    if(t1!=0)
    for(i=1;i<=gg1;i++){
            t3=1;
            while(walked[t3]==1){
                t3++;
            }
        for(j=1;j<=gg1;j++){
            if(memcmp(q5[j],q5[t3],sizeof(q5[0]))<0&&walked[j]==0){ //j小于t3
                t3=j;
            }
        }
        walked[t3]=1;
        for(k=1;k<=n;k++)
            cout << q5[t3][k];
        cout << endl;
    }
    if(gg1==1&&t1==0){
        for(i=1;i<=n;i++)
            cout << 1;
        cout << endl;
    }
    if(gg1<1)
        cout << "IMPOSSIBLE" <<endl;
    return 0;
}


### 回答1: 题目描述 有N头奶牛,它们在M个牛棚之间相互转移。每个牛棚里有一些奶牛,每分钟可以容纳一头奶牛。一头奶牛从一个牛棚走到另一个牛棚需要一分钟的时间。现在,这些奶牛要开一个牛派对,它们要在同一时间到达同一个牛棚,所以它们需要在某个牛棚等待一段时间。你需要计算最小的等待时间,使得所有奶牛都能够在同一时间到达同一个牛棚。 输入格式 第一行包含三个整数N,M,X。 接下来M行,每行包含三个整数a,b,t,表示牛棚a和牛棚b之间有一条双向边,需要t分钟才能通过。 输出格式 输出一个整数,表示最小等待时间。 数据范围 1≤N≤500 1≤M≤10000 1≤X≤N 1≤a,b≤N 1≤t≤1000 输入样例#1 3 3 1 1 2 5 2 3 5 1 3 10 输出样例#1 5 输入样例#2 4 5 4 1 2 10 2 3 10 3 4 10 4 1 10 1 3 20 输出样例#2 30 算法1 (最短路) $O(N^3)$ Dijkstra算法 Dijkstra(迪杰斯特拉)算法是由荷兰计算机科学家狄克斯特拉于1956年发明的,因此又叫狄克斯特拉算法。 Dijkstra算法是一种贪心算法,用于求解一个节点到其他所有节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止。 具体做法是:设立一个数组dis来保存源点到各个顶点的最短距离和一个数组book[i]来记录一个顶点是否已经在队列中。 初始时,原点s的路径权重被赋为0 (dis[s] = 0)。若对于顶点s存在能直接到达的边(s,m),则把dis[m]设为w(s, m),同时把所有其他(s不能直接到达的)顶点的路径长度设为无穷大。初始时,所有顶点并不属于任何已知最短路径所包含的顶点集合,因此都被标记为未知最短路径长度。当算法结束时,dis[v]中存储的便是源点s到顶点v的最短路径,或者如果从s无法到达v,则值为INF。 Dijkstra算法流程: 算法流程: 1. 将所有顶点分为两部分:已知最短路的顶点集合P和未知最短路的顶点集合Q。 2. 初始时,顶点集合P中只有源点s一个元素,以源点s为起点向外扩展。 3. 每次从顶点集合Q中选取一个顶点u(u的dist最小),并加入到顶点集合P中,同时以u为中心进行扩展。 4. 重复步骤3,直到顶点集合Q为空或者终点被加入到顶点集合P中。 5. 算法结束,最短路径保存在dis数组中。 时间复杂度 Dijkstra算法的时间复杂度为O(N^2)。由于N较小,因此可以通过本题。 参考文献 Dijkstra算法讲解 C++ 代码 算法2 (最短路) $O(N^2)$ Floyd算法 Floyd算法又称为插点法,是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法,与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 Floyd算法的基本思想 设G=(V,E)是一个带权有向图,其邻接矩阵为W。V={v1,v2,……,vn},W[1:n,1:n],则该图的Floyd算法可描述如下: 时间复杂度 Floyd算法的时间复杂度为O(N^3)。由于N较小,因此可以通过本题。 参考文献 Floyd算法讲解 C++ 代码 算法3 (最短路) $O(N^2)$ Bellman-Ford算法 Bellman-Ford算法是一种单源最短路径算法,可以处理负权边,但不能处理负权回路。 Bellman-Ford算法的基本思想 对于图中的任意一条边(u, v),Bellman-Ford算法会对每一条边进行一次松弛操作(Relax),并且这些操作是按照顺序进行的:当算法进行第i次松弛操作时,它只会改变长度为i+1的路径上的顶点的值。因此,当算法执行完第n-1次松弛操作后,路径长度最长不超过n-1,此时所有最短路径都已经求出。 时间复杂度 Bellman-Ford算法的时间复杂度为O(N*M)。由于N和M的范围较小,因此可以通过本题。 参考文献 Bellman-Ford算法讲解 C++ 代码 ### 回答2Usaco 2007 Feb的问题是关于Cow Party的。这个问题中,农夫约翰有N头奶牛,它们之间通过一些路径相互连接,并且每个路径都有一个长度。约翰想要在某个时间将它的所有奶牛聚集在一起举办一个派对,现在他想知道所有奶牛从各自的位置到达聚会地点所需的最短时间。 为了解决这个问题,我们可以使用Dijkstra算法。我们首先需要创建一个节点集合,包含所有的奶牛和派对地点,并且初始化每个节点的最短时间为无穷大。接下来,我们选取一个起点节点--聚会地点,并将它的最短时间设置为0。然后我们开始遍历所有的节点,每次选择一个最短时间未确定的节点,并更新它的邻居节点的最短时间。我们重复这个过程,直到所有节点的最短时间都确定。 在更新节点的最短时间时,我们需要根据节点之间的路径长度来更新。我们检查从当前节点到邻居节点的路径长度加上当前节点的最短时间是否小于邻居节点目前的最短时间。如果是,则更新邻居节点的最短时间为新的最短时间。 最后,我们可以得到所有奶牛到达聚会地点所需的最短时间。我们找到所有奶牛起始位置的最长最短时间,即为我们的答案。 通过使用Dijkstra算法,我们可以解决这个问题并得到最优解。因此,Usaco 2007 Feb的Cow Party问题可以通过这种方法解决。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值