HDU 2828 DLX搜索

最新推荐文章于 2025-09-09 08:37:13 发布

转载最新推荐文章于 2025-09-09 08:37:13 发布 · 113 阅读

文章标签：

本文探讨了一种用于解决复杂电路控制问题的智能搜索算法，通过反复覆盖搜索来确定所有灯泡都能点亮所需的开关状态。算法利用深度优先搜索（DFS）策略，结合精确覆盖和反复覆盖的方法，确保在给定的电路连接下找到点亮所有灯泡的有效开关组合。该方法特别关注于处理电路中可能出现的错误连接，如反向控制关系，以确保解决方案的准确性。实例演示了算法如何在给定的输入条件下，输出正确的开关状态序列或指出不存在有效解决方案的情况。

Lamp

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 771 Accepted Submission(s): 230
Special Judge

Problem Description

There are several switches and lamps in the room, however, the connections between them are very complicated. One lamp may be controlled by several switches, and one switch may controls at most two lamps. And what’s more, some connections are reversed by mistake, so it’s possible that some lamp is lighted when its corresponding switch is “OFF”!

To make things easier, we number all the lamps from 1 to N, and all the switches 1 to M. For each lamps, we give a list of switches controlling it. For example, for Lamp 1, the list is “1 ON 3 OFF 9 ON”, that means Lamp 1 will be lighted if the Switch 1 is at the “ON” state OR the Switch 3 is “OFF” OR the Switch 9 is “ON”.

Now you are requested to turn on or off the switches to make all the lamps lighted.

Input

There are several test cases in the input. The first line of each test case contains N and M (1 <= N,M <= 500), then N lines follow, each indicating one lamp. Each line begins with a number K, indicating the number of switches controlling this lamp, then K pairs of “x ON” or “x OFF” follow.

Output

Output one line for each test case, each contains M strings “ON” or “OFF”, indicating the corresponding state of the switches. For the solution may be not unique, any correct answer will be OK. If there are no solutions, output “-1” instead.

Sample Input

2
1 ON 2 ON
1 OFF
1
1 ON
1 OFF

Sample Output

OFF ON
-1

DLX简单搜索。纠结了好久，行为2*m，每个开关ON，OFF两种状态，列为n，代表灯的状态，然后依照反复覆盖搜索。不须要估价函数，用一个vis数组记录开关状态即可。

代码：

/* ***********************************************
Author :rabbit
Created Time :2014/4/9 17:58:16
File Name :7.cpp
************************************************ */
#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <string>
#include <time.h>
#include <math.h>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-8
#define pi acos(-1.0)
typedef long long ll;
struct DLX{
    const static int maxn=200010;
    #define FF(i,A,s) for(int i = A[s];i != s;i = A[i])
    int L[maxn],R[maxn],U[maxn],D[maxn];
    int size,col[maxn],row[maxn],s[maxn],H[maxn];
    bool vis[1200];
    int ans[maxn],cnt;
    void init(int m){
        for(int i=0;i<=m;i++){
            L[i]=i-1;R[i]=i+1;U[i]=D[i]=i;s[i]=0;
        }
        memset(H,-1,sizeof(H));
        L[0]=m;R[m]=0;size=m+1;
        memset(vis,0,sizeof(vis));
    }
    void link(int r,int c){
         U[size]=c;D[size]=D[c];U[D[c]]=size;D[c]=size;
         if(H[r]<0)H[r]=L[size]=R[size]=size;
         else {
             L[size]=H[r];R[size]=R[H[r]];
             L[R[H[r]]]=size;R[H[r]]=size;
         }
         s[c]++;col[size]=c;row[size]=r;size++;
     }
    void del(int c){//精确覆盖
        L[R[c]]=L[c];R[L[c]]=R[c];  
        FF(i,D,c)FF(j,R,i)U[D[j]]=U[j],D[U[j]]=D[j],--s[col[j]];  
    }  
    void add(int c){  //精确覆盖
        R[L[c]]=L[R[c]]=c;  
        FF(i,U,c)FF(j,L,i)++s[col[U[D[j]]=D[U[j]]=j]];  
    }  
    bool dfs(int k){//精确覆盖
        if(!R[0]){  
            cnt=k;return 1;  
        }  
        int c=R[0];FF(i,R,0)if(s[c]>s[i])c=i;  
        del(c);  
        FF(i,D,c){  
            FF(j,R,i)del(col[j]);  
            ans[k]=row[i];if(dfs(k+1))return true;  
            FF(j,L,i)add(col[j]);  
        }  
        add(c);  
        return 0;
    }  
    void remove(int c){//反复覆盖
        FF(i,D,c)L[R[i]]=L[i],R[L[i]]=R[i];
    }
     void resume(int c){//反复覆盖
         FF(i,U,c)L[R[i]]=R[L[i]]=i;
     }
    int A(){//估价函数
        int res=0;
        memset(vis,0,sizeof(vis));
        FF(i,R,0)if(!vis[i]){
                res++;vis[i]=1;
                FF(j,D,i)FF(k,R,j)vis[col[k]]=1;
            }
        return res;
    }
    bool dance(int now){//反复覆盖
        if(R[0]==0)return 1;
            int temp=INF,c;
            FF(i,R,0)if(temp>s[i])temp=s[i],c=i;
            FF(i,D,c){
                if(vis[row[i]^1])continue;
                vis[row[i]]=1;remove(i);
                FF(j,R,i)remove(j);
                if(dance(now+1))return 1;
                FF(j,L,i)resume(j);
                resume(i);vis[row[i]]=0;
            }
            return 0;
    }
}dlx;
int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        dlx.init(n);
        for(int i=1;i<=n;i++){
            int a,b;char str[44];
            scanf("%d",&a);
            while(a--){
                scanf("%d%s",&b,str);
                if(str[1]=='N')dlx.link((b-1)<<1,i);
                else dlx.link((b-1)<<1|1,i);
            }
        }
        if(!dlx.dance(0))puts("-1");
        else{
            if(!dlx.vis[1])printf("ON");else printf("OFF");
            for(int i=2;i<(m<<1);i+=2){
                if(!dlx.vis[i])printf(" OFF");else printf(" ON");
            }
			puts("");
        }
    }
    return 0;
}