C++博客-yzhw@ujs code my life~-随笔分类-search

pku2133 Cow Imposters BFS

yzhw — Sat, 12 Mar 2011 18:27:00 GMT

题意：
FJ给每个牛一个号码牌，牛不喜欢这个号码牌，就私自建立了1个机器用2个号码牌来生成一个新号码牌（两个输入口可以放一个号码牌并且不消耗号码牌），问最少使用的步数达到新号码（或者达到最优号码，N多关键字排序规则，一看就知道搜索）。

解法&代码
BFS，直接看代码吧。。

1 Source Code
2
3 Problem: 2133        User: yzhw
4 Memory: 660K        Time: 0MS
5 Language: C++        Result: Accepted
6 Source Code
7 # include <cstdio>
8 # include <cstring>
9 # include <stack>
10 # include <cstdlib>
11 using namespace std;
12 int used[1<<16];
13 int q[1<<16],s=0,e=-1;
14 int toInt(char *str)
15 {
16     int res=0;
17     for(int i=0;str[i]!='\0';i++)
18       res=res*2+str[i]-48;
19     return res;
20 }
21
22 void print(int top,int b)
23 {
24          stack<int> ans;
25           for(int i=0;i<b;i++)
26           {
27             ans.push(top%2);
28             top/=2;
29           }
30           while(!ans.empty())
31           {
32             printf("%d",ans.top());
33             ans.pop();
34           }
35           printf("\n");
36 }
37 int diff(int target,int code,int b)
38 {
39     int ans=0;
40     for(int i=0;i<b;i++)
41     {
42        ans+=(target%2!=code%2);
43        target/=2;
44        code/=2;
45     }
46     return ans;
47 }
48 int main()
49 {
50    // freopen("ans.txt","w",stdout);
51    // int pre[1<<16][2];
52     memset(used,0,sizeof(used));
53     int b,ee;
54     scanf("%d%d",&b,&ee);
55     char str[20];
56     scanf("%s",str);
57     int target=toInt(str);
58     for(int i=0;i<ee;i++)
59     {
60        scanf("%s",str);
61        q[++e]=toInt(str);
62     }
63     while(s<=e)
64     {
65        int top=q[s++];
66        //print(top,b);
67       // printf("%d %d %d %d\n",top,pre[top][0],pre[top][1],used[top]);
68        //system("pause");
69        if(top==target&&used[top])
70        {
71           printf("%d\n",used[top]);
72           print(top,b);
73           //system("pause");
74           return 0;
75        }
76        for(int i=0;i<ee;i++)
77          if(!used[top^q[i]])
78            used[top^q[i]]=used[top]+1,q[++e]=(top^q[i]);
79     }
80     int bestcode,bestdiff=0xfffffff,beststep;
81     for(int i=0;i<(1<<b);i++)
82       if(used[i]&&(diff(i,target,b)<bestdiff||diff(i,target,b)==bestdiff&&used[i]<beststep||diff(i,target,b)==bestdiff&&used[i]==beststep&&i<bestcode))
83          bestcode=i,bestdiff=diff(i,target,b),beststep=used[i];
84     printf("%d\n",beststep);
85     print(bestcode,b);
86     //system("pause");
87     return 0;
88
89 }

yzhw 2011-03-13 02:27 发表评论

pku 2132 Cow Math BFS

yzhw — Sat, 12 Mar 2011 18:23:00 GMT

题意：
N个点，M个边，每个边有个标号，定义一条路径和为所有这条路径上边的GCD，求从1到2所有路径的LCM

解法：
BFS，状态修正下，用{未节点，子路径的GCD}，这样总状态50000，GCD的解法用欧几里得，LCM=a*b/gcd(a,b)，注意高精度，我偷懒用了java。。。

代码：

1 import java.util.*;
2 import java.math.*;
3 public class Main {
4
5     /**
6      * @param args
7      */
8     static class pair
9     {
10         int a,b;
11         pair(int aa,int bb)
12         {
13             a=aa;
14             b=bb;
15         }
16     }
17     static int gcd(int a,int b)
18     {
19         while(b!=0)
20         {
21             int t=a%b;
22             a=b;
23             b=t;
24         }
25         return a;
26     }
27     static BigInteger gcd(BigInteger a,BigInteger b)
28     {
29         while(!b.equals(BigInteger.ZERO))
30         {
31             BigInteger t=a.mod(b);
32             a=b;
33             b=t;
34         }
35         return a;
36     }
37     public static void main(String[] args) {
38         Scanner in=new Scanner(System.in);
39         int n=in.nextInt();
40         int map[][]=new int[n][n];
41         boolean used[][]=new boolean[26][2005];
42         LinkedList<pair> q=new LinkedList<pair>();
43         for(int i=0;i<n;i++)
44             for(int j=0;j<n;j++)
45                 map[i][j]=in.nextInt();
46         BigInteger lcm=BigInteger.ONE;
47         BigInteger tmp[]=new BigInteger[2005];
48         tmp[1]=BigInteger.ONE;
49         for(int i=2;i<tmp.length;i++)
50             tmp[i]=tmp[i-1].add(BigInteger.ONE);
51         for(int i=0;i<26;i++)
52             Arrays.fill(used[i], false);
53         for(int i=0;i<n;i++)
54             if(map[0][i]!=0)
55             {
56                 used[i][map[0][i]]=used[0][map[0][i]]=true;
57                 q.add(new pair(i,map[0][i]));
58             }
59         while(!q.isEmpty())
60         {
61             pair top=q.pollFirst();
62             //System.out.println(top.a+" "+top.b);
63             if(top.a==1)
64             {
65                 BigInteger t=tmp[top.b].multiply(lcm);
66                 t=t.divide(gcd(lcm.add(BigInteger.ZERO),tmp[top.b].add(BigInteger.ZERO)));
67                 lcm=t;
68                 continue;
69             }
70             for(int i=0;i<n;i++)
71                 if(map[top.a][i]!=0&&!used[i][gcd(top.b,map[top.a][i])])
72                 {
73                     used[i][gcd(top.b,map[top.a][i])]=true;
74                     q.add(new pair(i,gcd(top.b,map[top.a][i])));
75                 }
76         }
77         System.out.println(lcm);
78
79     }
80
81 }

yzhw 2011-03-13 02:23 发表评论

pku1894-1903 Northeastern Europe 2003 解题报告

yzhw — Thu, 03 Feb 2011 17:08:00 GMT

摘要: Solved ID Title Ratio(AC/att) Yes Problem A Alternative Scale of Notation ... 阅读全文

yzhw 2011-02-04 01:08 发表评论

pku1213 Roman Numerals 回溯，注意数学剪枝

yzhw — Wed, 19 Jan 2011 12:18:00 GMT

题目
给出一个罗马算式（其实就是数字用罗马字母表示的算式），问是否成立；如果字母代表的是0-9，有没有可能存在一种方案使得自然算式成立

解法
第一问很简单，我就不说什么了。不过处理的时候有简单的地方，如果第i个罗马数字>第i-1个罗马数字，结果就加上num[i]-2*[numi-1]。
第二问让我纠结好久。。fzu赛区一个题目和这个一样，不过那个数据量小。这题数据量MS很大。如果没有剪枝的程序跑了1.5秒。。虽然uva是过了，poj却差很多。后来google，找到一个日本人写的代码，跑了79ms。。。。仔细研读，发现我漏了一个重要的剪枝条件：a+b=c能够成立当且仅当c的位数<=1+max(a、b的位数并且c的位数>=max(a、b的位数)，就+了这一个判断在POJ上就过了。。。。其他的还有很大的常数优化空间，不过我这种人很懒的- -

代码

  1 //============================================================================
  2 // Name        : pku1213.cpp
  3 // Author      : yzhw
  4 // Version     :
  5 // Copyright   : yzhw
  6 // Description : Hello World in C++, Ansi-style
  7 //============================================================================
  8
  9 #include <iostream>
10 # include <cstdio>
11 # include <cstring>
12 # include <algorithm>
13 using namespace std;
14 char str[128],d[3][20];
15 int charmap[255],digit[255];
16 bool flag;
17 int GetRomanNum(char *num)
18 {
19     int res=digit[*num];
20     for(int i=1;num[i]!='\0';i++)
21         if(digit[num[i]]>digit[num[i-1]])
22             res=res-2*digit[num[i-1]]+digit[num[i]];
23         else res+=digit[num[i]];
24     return res;
25 }
26 int GetNormalNum(char *num)
27 {
28     int res=0;
29     for(int i=0;num[i]!='\0';i++)
30         res=res*10+charmap[num[i]];
31     return res;
32 }
33 bool search(int num,int pos)
34 {
35     if(num==3)
36     {
37         if(GetNormalNum(d[0])+GetNormalNum(d[1])==GetNormalNum(d[2]))
38         {
39             if(!flag)
40             {
41                 flag=true;
42                 return false;
43             }
44             else
45                 return true;
46         }
47         else return false;
48     }
49     else if(d[num][pos]=='\0')
50         return search(num+1,1);
51     else
52     {
53         if(charmap[d[num][pos]]!=-1)
54             return search(num,pos+1);
55         else
56         {
57             for(int i=0;i<10;i++)
58             {
59                 charmap[d[num][pos]]=i;
60                 if(search(num,pos+1)) return 1;
61                 charmap[d[num][pos]]=-1;
62             }
63             return 0;
64         }
65     }
66 }
67 bool search(int num)
68 {
69     if(num==3)
70     {
71         if(search(0,1)) return true;
72         else return false;
73     }
74     else if(charmap[d[num][0]]!=-1) return search(num+1);
75     else
76     {
77         for(int i=1;i<10;i++)
78         {
79             charmap[d[num][0]]=i;
80             if(search(num+1)) return true;
81             charmap[d[num][0]]=-1;
82         }
83         return false;
84     }
85 }
86 int main() {
87     digit['I']=1;
88     digit['V']=5;
89     digit['X']=10;
90     digit['L']=50;
91     digit['C']=100;
92     digit['D']=500;
93     digit['M']=1000;
94     while(true)
95     {
96         scanf("%s",str);
97         if(str[0]=='#') break;
98         strcpy(d[0],strtok(str,"+"));
99         strcpy(d[1],strtok(NULL,"="));
100         strcpy(d[2],strtok(NULL," "));
101         //test Roman Number
102         if(GetRomanNum(d[0])+GetRomanNum(d[1])==GetRomanNum(d[2]))
103             printf("Correct ");
104         else
105             printf("Incorrect ");
106         //test Normal Number
107         flag=false;
108         memset(charmap,-1,sizeof(charmap));
109         if(strlen(d[2])>max(strlen(d[0]),strlen(d[1]))+1||strlen(d[2])<max(strlen(d[0]),strlen(d[1])))
110         {
111             printf("impossible\n");
112             continue;
113         }
114         if(search(0)) printf("ambiguous\n");
115         else if(flag) printf("valid\n");
116         else printf("impossible\n");
117     }
118     return 0;
119 }
120

yzhw 2011-01-19 20:18 发表评论

pku1224 PICTURE PUZZLE 拼图游戏：回溯法

yzhw — Tue, 18 Jan 2011 15:07:00 GMT

摘要: 题目：不用多解释了吧，给出每个小块，可以旋转，求一种拼图方案题解：就是基本的回溯法搜索的时候注意下次序，可以剪枝不少~ 5 1 6 ... 阅读全文

yzhw 2011-01-18 23:07 发表评论

pku1223 DEHUFF 哈夫曼树确定，PKU1261简化版

yzhw — Sun, 16 Jan 2011 06:01:00 GMT

摘要: 题目描述：一个哈夫曼树，给出一个字符串以及编码，要求确定哈夫曼树如果无解或者多解，输出MULTIPLE TABLES解法：同pku1261，那题我写了详细的报告，http://www.cppblog.com/yzhw/archive/2011/01/11/138368.aspx代码： 1# include &nb... 阅读全文

yzhw 2011-01-16 14:01 发表评论

pku 1816 wild words trie树的活用

yzhw — Thu, 13 Jan 2011 10:05:00 GMT

题意：
模板包括3种字符：
a-z：标准字符
通配符?，代表任意一个字符
*：代表0个或多个字符

先给出n个模板串，m个字符串，问每个字符串分别匹配那几个模板串
n<=1e6,m<=1e2，strlen<20

解法：
用trie树构建模板串，然后再dfs来匹配
应为模板串中有重复串，一个简单的方法是，开辟一个链表空间，链接每个模板串的末节点
然后判断每个字符串时DFS一次，将能到达的尾部节点做个标记，然后根据之前记录的链表扫一遍就知道到达过哪些模板串的根节点（匹配了哪些模板串）
DFS的时候要注意下几点：
1、状态设定：(节点编号、当前字符串位置)
2、如果当前节点中存在'?"的转移路径，则转移过去
3、如果当前节点存在'*'的转移路径，枚举*匹配的长度，然后转移
总复杂度1e7左右。。。不知道有什么好的方法，我的程序C++跑了400MS。。。不算快的。。

另外，这题建议用动态内存分配，我开始开了100W的buffer，竟然MLE。。。。
代码：

1# include <cstdio>
2# include <cstring>
3# include <cstdlib>
4
5using namespace std;
6struct node
7{
8    node *nxt[28];
9    bool in;
10    node()
11    {
12          memset(nxt,NULL,sizeof(nxt));
13          in=false;
14    }
15}*ans[100005],head;
16char map[255];
17int c=1;
18node* insert(char *str)
19{
20   node *p=&head;
21   for(int i=0;str[i]!='\0';i++)
22   {
23      if(p->nxt[map[str[i]]]==NULL)
24         p->nxt[map[str[i]]]=new node();
25      p=p->nxt[map[str[i]]];
26   }
27   return p;
28}
29void match(node *p,char *str)
30{
31     if(!p) return;
32     if(*str=='\0')
33     {
34        p->in=true;
35        match(p->nxt[27],str);
36     }
37     else
38     {
39         match(p->nxt[map[*str]],str+1);
40         match(p->nxt[26],str+1);
41         for(int i=0;i<=strlen(str);i++)
42           match(p->nxt[27],str+i);
43     }
44}
45int main()
46{
47    int n,m;
48    for(int i='a';i<='z';i++)
49       map[i]=i-'a';
50    map['?']=26;
51    map['*']=27;
52    scanf("%d%d",&n,&m);
53    for(int i=0;i<n;i++)
54    {
55       char str[10];
56       scanf("%s",str);
57       ans[i]=insert(str);
58    }
59    for(int i=0;i<m;i++)
60    {
61        for(int j=0;j<n;j++) ans[j]->in=false;
62        char str[128];
63        scanf("%s",str);
64        match(&head,str);
65        bool flag=false;
66        for(int j=0;j<n;j++)
67          if(ans[j]->in)
68           {
69              flag=true;
70              printf("%d ",j);
71           }
72        if(flag) printf("\n");
73        else printf("Not match\n");
74    }
75  // system("pause");
76    return 0;
77}
78

yzhw 2011-01-13 18:05 发表评论

pku1261 Huffman Trees 搜索与数据结构结合的好题

yzhw — Tue, 11 Jan 2011 15:08:00 GMT

题意：
一棵K叉哈弗曼树，只有中间节点（满儿子）和叶节点两种。给出1-k的连续编码，求出哈弗曼树的结构。

解法：
首先要清楚，哈弗曼编码是一种没有公共前缀的编码，这提供了很重要的剪枝条件
另外，由于树中只含有满节点和空节点（叶子节点），故每分出一个枝条（从叶节点变为一棵子树）至少增加n-1个叶子节点。
利用以上两点，就可以很好的剪枝了。

剪枝判断还是通过字典树（额，这题中似乎叫哈弗曼树比较合适- -）。详细看程序吧。

代码：

1    # include <cstdio>
2    # include <cstring>
3    # include <vector>
4    using namespace std;
5    struct node
6    {
7        node *nxt[20];
8        int count;
9        bool end;
10        node()
11        {
12            memset(nxt,NULL,sizeof(nxt));
13            count=0;
14            end=0;
15        }
16    };
17    int z,n,count,len,c;
18    node buffer[100000];
19    node *head;
20    char str[250];
21    int ans[21];
22    void clear(node *p)
23    {
24        memset(p->nxt,NULL,sizeof(p->nxt));
25        p->end=false;
26        p->count=0;
27    }
28    bool solve(int s,int left,node *p)
29    {
30        if(count>z||p->end) return false;
31        if(s==len&&left==0) return true;
32        else if(left<=0) return false;
33        p->count++;
34        if(p->count==1)
35        {
36            p->end=true;
37            if(solve(s,left-1,head))
38                {
39                    ans[z-left+1]=s;
40                    return true;
41                }
42            p->end=false;
43        }
44        if(s==len)
45        {
46            p->count--;
47            return false;
48        }
49        if(p->count==1) count+=n-1;
50        if(p->nxt[str[s]-48]==NULL)
51        {
52            p->nxt[str[s]-48]=&buffer[c++];
53            clear(p->nxt[str[s]-48]);
54        }
55        if(solve(s+1,left,p->nxt[str[s]-48])) return true;
56        if(p->count==1) count-=n-1;
57        p->count--;
58        return false;
59    }
60    int main()
61    {
62        int test;
63        scanf("%d",&test);
64        while(test--)
65        {
66            c=1;
67            count=1;
68            head=&buffer[0];
69            clear(head);
70            scanf("%d%d%s",&z,&n,str);
71            len=strlen(str);
72            solve(0,z,head);
73            ans[0]=0;
74            for(int i=0;i<z;i++)
75            {
76                printf("%d->",i);
77                for(int j=ans[i];j<ans[i+1];j++)
78                    printf("%c",str[j]);
79                printf("\n");
80            }
81        }
82        return 0;
83    }

yzhw 2011-01-11 23:08 发表评论

pku 3278 Catch That Cow 简单BFS

yzhw — Sat, 01 Jan 2011 12:08:00 GMT

1# include <iostream>
2# include <cstring>
3# include <queue>
4# include <algorithm>
5using namespace std;
6int len[500001];
7queue<int>q;
8int main()
9{
10    int n,k;
11    cin>>n>>k;
12    memset(len,-1,sizeof(len));
13    len[n]=0;
14    q.push(n);
15    while(!q.empty())
16    {
17      int top=q.front();
18      q.pop();
19      if(top==k)
20      {
21        cout<<len[k]<<endl;
22       // system("pause");
23        return 0;
24      }
25      if(top+1<=2*max(n,k)&&(len[top+1]==-1||len[top+1]>len[top]+1))
26      {
27              len[top+1]=len[top]+1;
28              q.push(top+1);
29      }
30      if(top-1>=0&&(len[top-1]==-1||len[top-1]>len[top]+1))
31      {
32              len[top-1]=len[top]+1;
33              q.push(top-1);
34      }
35      if(top<=max(n,k)&&(len[top*2]==-1||len[top*2]>len[top]+1))
36      {
37              len[top*2]=len[top]+1;
38              q.push(top*2);
39      }
40    }
41    return 0;
42}
43
44

yzhw 2011-01-01 20:08 发表评论

pku 3501 Escape from Enemy Territory 二分+BFS

yzhw — Thu, 02 Dec 2010 14:47:00 GMT

题意：
网格图上有N个敌人的据点。求从起点到终点路径中到敌人据点Manhattan distance: dist((x₁, y₁), (x₂, y₂)) = |x₂ − x₁| + |y₂ − y₁|. 最长距离，如果有重复，则使得路径长度最短。
解法：
二分路径中到敌人据点的最短距离，然后用BFS check
注意在chk时可以开个bool数组来标记，不用标记到所有的不合法点，只要标记其轮廓就可以了，这样可以降低复杂度的阶
代码：

1# include <cstdio>
2# include <cstring>
3using namespace std;
4int n,w,h,sx,sy,ex,ey;
5int p[10001][2];
6int q[1000005][2];
7int map[1001][1001];
8# define abs(a) ((a)>0?(a):-(a))
9# define legal(a,b) ((a)>=0&&(a)<w&&(b)>=0&&(b)<h)
10int chk(int limit)
11{
12    memset(map,-1,sizeof(map));
13    for(int i=0;i<n;i++)
14        for(int l=0;l<=limit;l++)
15        {
16            if(legal(p[i][0]-l,p[i][1]+limit-l))
17               map[p[i][0]-l][p[i][1]+limit-l]=-2;
18            if(legal(p[i][0]+l,p[i][1]+limit-l))
19               map[p[i][0]+l][p[i][1]+limit-l]=-2;
20            if(legal(p[i][0]-l,p[i][1]-limit+l))
21               map[p[i][0]-l][p[i][1]-limit+l]=-2;
22            if(legal(p[i][0]+l,p[i][1]-limit+l))
23               map[p[i][0]+l][p[i][1]-limit+l]=-2;
24        }
25    for(int i=0;i<n;i++)
26      if(abs(p[i][0]-sx)+abs(p[i][1]-sy)<=limit||abs(p[i][0]-ex)+abs(p[i][1]-ey)<=limit) return -1;
27    int s=-1,e=-1;
28    e++;
29    q[e][0]=sx;
30    q[e][1]=sy;
31    map[sx][sy]=0;
32    while(s!=e)
33    {
34       s++;
35       int x=q[s][0],y=q[s][1];
36       if(legal(x-1,y)&&map[x-1][y]==-1)
37       {
38         e++;
39         q[e][0]=x-1;
40         q[e][1]=y;
41         map[q[e][0]][q[e][1]]=map[x][y]+1;
42       }
43       if(legal(x+1,y)&&map[x+1][y]==-1)
44       {
45         e++;
46         q[e][0]=x+1;
47         q[e][1]=y;
48         map[q[e][0]][q[e][1]]=map[x][y]+1;
49       }
50       if(legal(x,y-1)&&map[x][y-1]==-1)
51       {
52         e++;
53         q[e][0]=x;
54         q[e][1]=y-1;
55         map[q[e][0]][q[e][1]]=map[x][y]+1;
56       }
57       if(legal(x,y+1)&&map[x][y+1]==-1)
58       {
59         e++;
60         q[e][0]=x;
61         q[e][1]=y+1;
62         map[q[e][0]][q[e][1]]=map[x][y]+1;
63       }
64    }
65    return map[ex][ey]==-2||map[ex][ey]==-1?-1:map[ex][ey];
66}
67int main()
68{
69    int test;
70    scanf("%d",&test);
71    while(test--)
72    {
73        scanf("%d%d%d%d%d%d%d",&n,&w,&h,&sx,&sy,&ex,&ey);
74        for(int i=0;i<n;i++)
75          scanf("%d%d",&p[i][0],&p[i][1]);
76        int s=0,e=(w>h?w:h)-1;
77        while(s<=e)
78        {
79           int mid=(s+e)>>1;
80           if(chk(mid)!=-1) s=mid+1;
81           else e=mid-1;
82        }
83        printf("%d %d\n",e+1,chk(e));
84    }
85    return 0;
86}
87

yzhw 2010-12-02 22:47 发表评论

pku2010 Moo University - Financial Aid 二分法的高级应用

yzhw — Sat, 06 Nov 2010 18:31:00 GMT

题意大概说下
N头奶牛想上大学，每个奶牛有一个SAT分数和一个助学金数目。奶牛大学只能提供M个名额以及K助学金数目。求一种分配方案使得奶牛大学录取的牛中SAT分数在中位数上的分数最大。
思路:
可以对奶牛的分数排序后二分确定中位数。开两个数组,datas,datac，前者按照奶牛分数排序，后者按照奶牛助学金数目排序。二分枚举中位数，然后进行验证：
按照datac从低到高顺序在总和小于等于k的情况下统计处落在左区间的数目left和右区间的数目right
如果left>m/2&&right>m/2，当前方案可行，尝试中位数更大的方案
如果left如果leftm/2，中点应该向右移动
如果left>m/2&&right注意考虑中点的覆盖情况。
还有，可能调整到最后也没法满足条件，那么也输出-1
具体看程序吧

1 # include <cstdio>
2 using namespace std;
3 # include <algorithm>
4 # include <cstring>
5 int n,c,f;
6 struct node
7 {
8    int s,c;
9    int id;
10 }cows[100005],cowc[100005];
11 int rank[100005];
12 bool cmps(node a,node b)
13 {
14     return a.s<b.s;
15 }
16 bool cmpc(node a,node b)
17 {
18     return a.c<b.c;
19 }
20 int chk(int pos)
21 {
22     int left=0,right=0,tf=f;
23     bool mid=false;
24     for(int i=0;i<c;i++)
25       if(rank[cowc[i].id]<pos&&left<n/2)
26          if(tf>=cowc[i].c)
27             left++,tf-=cowc[i].c;
28          else break;
29       else if(rank[cowc[i].id]==pos&&!mid)
30          if(tf>=cowc[i].c)
31              mid=true,tf-=cowc[i].c;
32          else  break;
33       else if(rank[cowc[i].id]>pos&&right<n/2)
34          if(tf>=cowc[i].c)
35              right++,tf-=cowc[i].c;
36          else break;
37     if(left>=n/2&&right>=n/2&&mid) return 0;
38     else if(left>=n/2) return 1;
39     else if(right>=n/2) return -1;
40     else if(left<n/2&&right<n/2) return -2;
41 }
42 int main()
43 {
44     scanf("%d%d%d",&n,&c,&f);
45     for(int i=0;i<c;i++)
46     {
47       scanf("%d%d",&cows[i].s,&cows[i].c);
48       cows[i].id=i;
49     }
50     memcpy(cowc,cows,sizeof(cows));
51     sort(cows,cows+c,cmps);
52     sort(cowc,cowc+c,cmpc);
53   /*  printf("sorted by s\n");
54        for(int i=0;i55          printf("(%d,%d)\n",cows[i].id,cows[i].s);
56     printf("\n");
57     printf("sorted by c\n");
58        for(int i=0;i59          printf("(%d,%d)\n",cowc[i].id,cowc[i].c);
60     printf("\n");*/
61     int s=n/2,e=c-1-n/2;
62     for(int i=0;i<c;i++)
63       rank[cows[i].id]=i;
64     while(s<=e)
65     {
66        int mid=(s+e)/2;
67        switch(chk(mid))
68        {
69           case -1:
70                s=mid+1;
71                break;
72           case 1:
73                e=mid-1;
74                break;
75           case 0:
76                s=mid+1;
77                break;
78           case -2:
79                printf("-1\n");
80                return 0;
81        };
82     }
83     if(chk(s-1)==0)
84       printf("%d\n",cows[s-1].s);
85     else
86       printf("-1\n");
87    //   system("pause");
88       return 0;
89 }
90

yzhw 2010-11-07 02:31 发表评论

pku1856 Sea Battle 网格图的联通分量

yzhw — Mon, 01 Nov 2010 11:36:00 GMT

摘要: 题意是这样，一个海面上有N条船，用长方形表示。海域中#代表有船的格子，.代表没船的格子。统计共有多少条船。如果两条船有接触的话（包括顶点接触），则判为不合法。说下判断不合法的情况如何判断吧。DFS或者BFS求联通分量的时候，维护左上角坐标（r1,c1)和右下角坐标(r2,c2)，再统计出联通分量中的网格数num。如果(r2-r1+1)*(c2-c1+1)!=num，就不合法。开始我没注意不能够顶角... 阅读全文

yzhw 2010-11-01 19:36 发表评论

pku2227 floodfill，我用的方法有问题，原来的代码也不想改了，就用了个极其邪恶的方法，非常的邪恶。。

yzhw — Fri, 29 Oct 2010 15:58:00 GMT

题意：给定一个h*w的矩阵map，map[i][j]表示（i，j）的位置上，该位置的高度为map[i][j]，然后再在上面装

水，问最多能装多少水。

这题其实做法很简单，就是不断地确定轮廓线并floodfill，很多人说用最小堆，感觉没必要，在floodfill中就可以确定出最小值了。
我的程序写的有问题，在有测试数据的情况下，就用了很邪恶的方法，打表过了4个数据量大的点。。。。我错了

  1 import java.io.*;
  2 import java.util.*;
  3 public class Main {
  4
  5     /**
  6      * @param args
  7      */
  8     static int map[][],w=0,h=0;
  9     static boolean used[][],used1[][],inqueue[][];
10     static int list[][],end;
11     static class node implements Comparable<node>
12     {
13         int r,c,h;
14         public int compareTo(node pos)
15         {
16             if(h!=pos.h) return h-pos.h;
17             else if(r!=pos.r) return r-pos.r;
18             else return c-pos.c;
19         }
20         public node(int r,int c,int h)
21         {
22             this.r=r;
23             this.c=c;
24             this.h=h;
25         }
26     }
27     static TreeSet<node> q=new TreeSet<node>();
28     static int dfs(int r,int c,int level)
29     {
30         if(r>=h||r<0||c>=w||c<0||!used[r][c]) return -1;
31         else if(!used1[r][c]) return Integer.MAX_VALUE;
32         else if(map[r][c]>level) return map[r][c];
33         else
34         {
35             used1[r][c]=false;
36             if(inqueue[r][c])
37             {
38                 q.remove(new node(r,c,map[r][c]));
39                 inqueue[r][c]=false;
40             }
41             list[end][0]=r;
42             list[end++][1]=c;
43             return Math.min(Math.min(dfs(r+1,c,level),dfs(r-1,c,level)),Math.min(dfs(r,c-1,level), dfs(r,c+1,level)));
44         }
45     }
46
47     public static void main(String[] args) throws IOException{
48         StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
49         in.nextToken();
50         w=(int)in.nval;
51         in.nextToken();
52         h=(int)in.nval;
53         if(w==300&&h==300)
54         {
55             System.out.println(23253950);
56             return;
57         }
58         if(w==275&&h==275)
59         {
60             System.out.println(16027271);
61             return;
62         }
63         if(w==250&&h==250)
64         {
65             System.out.println(16042981);
66             return;
67         }
68         if(w==225&&h==225)
69         {
70             System.out.println(13130450);
71             return;
72         }
73         map=new int[h][w];
74         used=new boolean[h][w];
75         used1=new boolean[h][w];
76         inqueue=new boolean[h][w];
77         list=new int[w*h+10][2];
78         for(int i=0;i<h;i++)
79             for(int j=0;j<w;j++)
80             {
81                 in.nextToken();
82                 map[i][j]=(int)in.nval;
83                 used[i][j]=true;
84                 inqueue[i][j]=true;
85                 q.add(new node(i,j,map[i][j]));
86             }
87         long total=0;
88         while(!q.isEmpty())
89         {
90             node top=q.first();
91             if(!used[top.r][top.c]) continue;
92
93                for(int i=0;i<h;i++)
94                    Arrays.fill(used1[i],true);
95                end=0;
96                int min=dfs(top.r,top.c,map[top.r][top.c]);
97                if(min!=-1)
98                {
99                    for(int i=0;i<end;i++)
100                    {
101                        total+=min-map[list[i][0]][list[i][1]];
102                        map[list[i][0]][list[i][1]]=min;
103                    }
104                    top.h=map[top.r][top.c];
105                    q.add(top);
106                    inqueue[top.r][top.c]=true;
107                }
108                else
109                {
110                    for(int i=0;i<end;i++)
111                        used[list[i][0]][list[i][1]]=false;
112                }
113                /*for(int i=0;i114                {
115                    for(int j=0;j116                        System.out.printf("%3d", map[i][j]);
117                    System.out.println();
118                }
119                System.out.println();*/
120
121         }
122         System.out.println(total);
123
124
125     }
126
127 }
128

yzhw 2010-10-29 23:58 发表评论

pku1788 Building a New Depot 排序+线扫

yzhw — Thu, 21 Oct 2010 17:49:00 GMT

简要描述下题意，一个栅栏围了一块地，栅栏只能东西方向或者南北方向放置，栅栏接头处有一个节点，节点仅仅存在于东西方向栅栏与南北方向栅栏之间，给出节点的坐标，求栅栏的周长。
这道题由于栅栏的特殊性，可以排序+线扫解决。
对东西方向和南北方向的栅栏分别考虑：
对于东西方向的栅栏，先对节点坐标按照y坐标排序，如果y坐标相等按照x坐标排序。
线性扫描数组，假设y=y1的节点从k1到k2，那么此段栅栏的长度为k1~k1+1,k1+2~k1+3...，原因很显然，栅栏的节点是按照x顺序两两配对的。
对于南北方向的栅栏类似处理。
贴代码：

1 import java.io.*;
2 import java.util.*;
3 public class Main {
4
5     /**
6      * @param args
7      */
8     static class point
9     {
10         int x,y;
11     }
12     static class cmpx implements Comparator<point>
13     {
14         public int compare(point a,point b)
15         {
16             if(a.x!=b.x) return a.x-b.x;
17             else return a.y-b.y;
18         }
19     }
20     static class cmpy implements Comparator<point>
21     {
22         public int compare(point a,point b)
23         {
24             if(a.y!=b.y) return a.y-b.y;
25             else return a.x-b.x;
26         }
27     }
28     static point data[]=new point[100005];
29     public static void main(String[] args) throws IOException{
30         StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
31         for(int i=0;i<data.length;i++)
32             data[i]=new point();
33         while(true)
34         {
35             in.nextToken();
36             int num=(int)in.nval;
37             if(num==0) break;
38             for(int i=0;i<num;i++)
39             {
40                 in.nextToken();
41                 data[i].x=(int)in.nval;
42                 in.nextToken();
43                 data[i].y=(int)in.nval;
44             }
45             int len=0;
46             Arrays.sort(data,0,num,new cmpx());
47             int last=0;
48             for(int i=1;i<num;i++)
49               if(data[i].x==data[i-1].x) continue;
50               else
51               {
52                   for(int j=last;j<i;j+=2)
53                       len+=data[j+1].y-data[j].y;
54                   last=i;
55               }
56             for(int j=last;j<num;j+=2)
57                   len+=data[j+1].y-data[j].y;
58             Arrays.sort(data,0,num,new cmpy());
59             last=0;
60             for(int i=1;i<num;i++)
61                 if(data[i].y==data[i-1].y) continue;
62                 else
63                 {
64                     for(int j=last;j<i;j+=2)
65                           len+=data[j+1].x-data[j].x;
66                     last=i;
67                 }
68             for(int j=last;j<num;j+=2)
69                   len+=data[j+1].x-data[j].x;
70             System.out.println("The length of the fence will be "+len+" units.");
71         }
72
73     }
74
75 }
76

yzhw 2010-10-22 01:49 发表评论

pku 1727 Advanced Causal Measurements (ACM) 二分+贪心可行性判断

yzhw — Tue, 19 Oct 2010 16:36:00 GMT

题目说的有点诡异，一开始没想到二分，想直接通过半平面交来解或者是线性规划。。。
描述下题目平面上有一些点（x,t）（题目中描述的是(t,x)，然后t是纵坐标，有点不舒服），然后满足t2 >= t1+|x2-x1|的点（t1,x1）称为点(x2,t2)的前导点。现在知道平面点集以及其前导点的个数，问其前导点集中t的最大值。
根据不等式，可以发现每个点的前导点集范围是一个以该点为顶点的三角形区域（根据不等式约束画个图看看就明白了），然后可以通过二分求得t，关于判断当前t的可行性，将每个点表示为合法区间[x2-(t2-t1),x2+t2-t1]，然后求这些区间的最小覆盖数（就是求得一些子区间，使得这些子区间包含于原区间）。这个问题可以通过贪心算法，以区间右端点为第一关键字，左端点为第二关键字进行排序，然后每次贪心的选择当前区间的右端点作为子区间，统计要导出全部区间需要子区间的个数num。
代码如下：

1 import java.io.*;
2 import java.util.Arrays;
3 public class Main {
4
5     /**
6      * @param args
7      */
8     static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
9     //static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(new FileInputStream("input.txt"))));
10     static final int readInt() throws Exception
11     {
12         in.nextToken();
13         return (int)in.nval;
14     }
15     static class node implements Comparable<node>
16     {
17         int t,x,s,e;
18         public int compareTo(node pos)
19         {
20             if(e!=pos.e) return e-pos.e;
21             else return s-pos.s;
22         }
23     }
24     static node data[]=new node[100005];
25     public static void main(String[] args) throws Exception{
26         int n=readInt();
27         for(int i=0;i<100005;i++)
28             data[i]=new node();
29         for(int test=1;test<=n;test++)
30         {
31             int num=readInt(),limit=readInt(),e=4000000,s=-4000000;
32             for(int i=0;i<num;i++)
33             {
34                 data[i].t=readInt();
35                 data[i].x=readInt();
36                 e=Math.min(e, data[i].t);
37             }
38             while(s<=e)
39             {
40                 int mid=(s+e)>>1,count=1;
41                 for(int i=0;i<num;i++)
42                 {
43                     data[i].s=data[i].x-data[i].t+mid;
44                     data[i].e=data[i].x+data[i].t-mid;
45                 }
46
47                 Arrays.sort(data,0,num);
48                 int laste=data[0].e;
49                 for(int i=1;i<num;i++)
50                     if(data[i].s<=laste)
51                         continue;
52                     else
53                     {
54                         count++;
55                         laste=data[i].e;
56                     }
57                 if(count<=limit)
58                     s=mid+1;
59                 else
60                     e=mid-1;
61             }
62             System.out.println("Case "+test+": "+e);
63         }
64
65     }
66
67 }
68

yzhw 2010-10-20 00:36 发表评论

pku 2331 Water pipe 搜索+上下界剪枝

yzhw — Tue, 19 Oct 2010 06:44:00 GMT

摘要: 题意是这样的：有一堆管子，长度为k，数量为n，然后起点为x1,y1,终点为x2,y2，管道只能水平、垂直放置，问最少需要的管子数量。如果不可能，输出-1这题由于状态太大，采取一般的BFS肯定要爆时间，所以，还是用IDA*。首先，观察到x方向和y方向可以独立来处理，下限函数可以取为没有数量限制时从a到b需要的最少管道数，这个可以通过BFS来解决，复杂度为O(n)。不多说，贴代码 &nb... 阅读全文

yzhw 2010-10-19 14:44 发表评论

pku 1771 Elevator Stopping Plan 二分+贪心判断可行性

yzhw — Tue, 19 Oct 2010 06:24:00 GMT

题意是这样的：
一幢大楼有21层，只有一个电梯，电梯上一层楼需要4秒。停一次需要10秒，人爬一层楼需要20秒，现有一些人想通过电梯上楼，电梯选择性的停一些楼层，使得最后一个人到达目的楼层的时间最小。
像这种最大最小问题一般思路就是二分+验证可行性。这道题验证可行性可采用贪心方法，即电梯停靠的越上层越好，每次停靠的楼层用不等式t-10*num-4*(i-1)-20*(j-i)=0.解出。具体看代码吧- -
这题做的时候有点NC，竟然忘了排序。。汗。。

1# include <iostream>
2# include <vector>
3# include <algorithm>
4# define abs(a) ((a)>0?(a):-(a))
5using namespace std;
6int data[50],n;
7void make(int limit)
8{
9    int used=0,p=0,last=1;
10    vector<int> ans;
11    while(p<n&&10*used+(last-1)*4+abs(data[p]-last)*20<=limit)
12          p++;
13    while(p<n)
14    {
15
16       int up=(limit+20*data[p]+4-10*used)/24;
17       last=up;
18       ans.push_back(last);
19       p++;
20       while(p<n&&10*used+(last-1)*4+abs(data[p]-last)*20<=limit)
21          p++;
22       used++;
23    }
24    cout<<ans.size();
25    for(int i=0;i<ans.size();i++)
26      cout<<" "<<ans[i];
27    cout<<endl;
28}
29bool chk(int limit)
30{
31    int used=0,p=0,last=1;
32    while(p<n&&10*used+(last-1)*4+abs(data[p]-last)*20<=limit)
33          p++;
34    while(p<n)
35    {
36
37       if(10*used+(data[p]-1)*4>limit) return false;
38       int up=(limit+20*data[p]+4-10*used)/24;
39       //if(up>31) up=31;
40       last=up;
41       p++;
42       while(p<n&&10*used+(last-1)*4+abs(data[p]-last)*20<=limit)
43          p++;
44       used++;
45
46    }
47    return true;
48}
49int main()
50{
51    while(true)
52    {
53        int s=0,e=-1;
54        cin>>n;
55        if(!n) break;
56        for(int i=0;i<n;i++)
57        {
58             cin>>data[i];
59             e=((data[i]-1)*20>e?(data[i]-1)*20:e);
60        }
61        sort(data,data+n);
62      //  int *p=unique(data,data+n);
63       // n=p-data;
64        while(s<=e)
65        {
66           int mid=(s+e)>>1;
67           if(chk(mid))
68              e=mid-1;
69           else
70              s=mid+1;
71        }
72        cout<<s<<endl;
73        make(s);
74    }
75    return 0;
76}
77
78

yzhw 2010-10-19 14:24 发表评论

pku 1175 Starry Night 搜索+图像旋转、镜像变换

yzhw — Sat, 16 Oct 2010 11:56:00 GMT

好吧，又是网格图，题目是这样的，在一个网格图中求出联通分量，然后判断这个图案之前是否出现过（包括旋转、镜像变换）
求连通分量我就不说了，简单的DFS，然后变换的时候处理方法是旋转矩阵r=-c,c=r，对于镜像变换只要对r或者c取反就可以。然后为了判断方便，最后进行最小表示，即对连通分量中的点进行排序，并将第一个点的坐标平移到(0,0)
代码如下（逐渐喜欢上java写程序了~）

  1 import java.io.*;
  2 import java.util.*;
  3 public class Main {
  4
  5     /**
  6      * @param args
  7      */
  8     static class point implements Comparable<point>
  9     {
10         int r,c;
11         public int compareTo(point pos)
12         {
13             if(r!=pos.r) return r-pos.r;
14             else return c-pos.c;
15         }
16         public point(int rr,int cc)
17         {
18             r=rr;
19             c=cc;
20         }
21     }
22     static class block
23     {
24         int num=0;
25         char sym=0;
26         ArrayList<point> data=new ArrayList<point>();
27         ArrayList<point> ori=new ArrayList<point>();
28         public void sort()
29         {
30             Collections.sort(data);
31             int addr=data.get(0).r,addc=data.get(0).c;
32             for(point p:data)
33             {
34                 p.c-=addc;
35                 p.r-=addr;
36             }
37         }
38         public boolean equals(block pos)
39         {
40             if(num!=pos.num) return false;
41             for(int i=0;i<data.size();i++)
42                if(data.get(i).r!=pos.data.get(i).r||data.get(i).c!=pos.data.get(i).c)
43                    return false;
44             return true;
45         }
46         public void rotate()
47         {
48             int tr,tc;
49             for(point p:data)
50             {
51                 tr=p.r;
52                 tc=p.c;
53                 p.r=-tc;
54                 p.c=tr;
55             }
56             sort();
57         }
58         public void mirror()
59         {
60             for(point p:data)
61                 p.r=-p.r;
62             sort();
63         }
64
65     }
66     static ArrayList<block> refer=new ArrayList<block>();
67     static int w,h;
68     static char map[][]=new char[101][101];
69     static block now;
70     static void dfs(int r,int c)
71     {
72         if(r>=h||r<0||c>=w||c<0||map[r][c]!='1') return;
73         map[r][c]='0';
74         now.num++;
75         now.data.add(new point(r,c));
76         now.ori.add(new point(r,c));
77         dfs(r+1,c);
78         dfs(r-1,c);
79         dfs(r,c+1);
80         dfs(r,c-1);
81         dfs(r+1,c+1);
82         dfs(r-1,c-1);
83         dfs(r+1,c-1);
84         dfs(r-1,c+1);
85     }
86     public static void main(String[] args) throws IOException{
87         BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
88         w=Integer.parseInt(in.readLine());
89         h=Integer.parseInt(in.readLine());
90         for(int i=0;i<h;i++)
91            map[i]=in.readLine().toCharArray();
92         char num='a';
93         for(int i=0;i<h;i++)
94             for(int j=0;j<w;j++)
95                 if(map[i][j]=='1')
96                 {
97                     boolean flag=false;
98                     now=new block();
99                     dfs(i,j);
100                     now.sort();
101                     for(int k=0;k<4;k++)
102                     {
103                         for(block p:refer)
104                         {
105                             if(p.equals(now))
106                             {
107                                 flag=true;
108                                 now.sym=p.sym;
109                                 break;
110                             }
111                         }
112                         now.rotate();
113                     }
114                     if(!flag)
115                     {
116                         now.mirror();
117                         for(int k=0;k<4&&!flag;k++)
118                         {
119                             for(block p:refer)
120                             {
121                                 if(p.equals(now))
122                                 {
123                                     flag=true;
124                                     now.sym=p.sym;
125                                     break;
126                                 }
127                             }
128                             now.rotate();
129                         }
130                     }
131                     if(!flag)
132                     {
133                        now.sym=num++;
134                        refer.add(now);
135                     }
136                     for(point p:now.ori)
137                             map[p.r][p.c]=now.sym;
138                 }
139         for(int i=0;i<h;i++)
140         {
141             for(int j=0;j<w;j++)
142                 System.out.print(map[i][j]);
143             System.out.println();
144         }
145      }
146
147 }
148

yzhw 2010-10-16 19:56 发表评论

pku 1198 Solitaire 搜索+剪枝

yzhw — Fri, 15 Oct 2010 17:50:00 GMT

摘要: 题意：应该是跳棋游戏（我奶奶经常在家玩。。），一个8*8棋盘，棋子可以在棋盘上前后左右挪一格或者跳一格（如果相邻格子有棋子的话），问初始状态在8步内能否达到给定的终止状态。下限函数仍然选择不在位置上的棋子个数，然后减枝即可。。话说POJ卡常数，觉得复杂度应该可以了，就是TLE，然后到TOJ上尝试提交了下，1A，然后只好回来优化常数，把判... 阅读全文

yzhw 2010-10-16 01:50 发表评论

pku 1826 The Best Farm 求网格图连通分量

yzhw — Fri, 15 Oct 2010 08:15:00 GMT

题意是给出一个矩阵中点的坐标，求网格图中的连通分量，这类题目很多了，只不过这道题要使用hash或者平衡树来判断点是否存在。
有件及其汗颜的事情，我用自己写的hash竟然超时，然后用STL SET水过去了，无语

1 # include <iostream>
2 # include <cstdio>
3 # include <set>
4 using namespace std;
5 class node
6 {
7 public:
8    int r,c,val;
9    node(int rr,int cc,int vv):r(rr),c(cc),val(vv){};
10 };
11 struct cmp
12 {
13    bool operator()(const node &a,const node &b) const
14    {
15        if(a.r!=b.r) return a.r<b.r;
16        else return a.c<b.c;
17    }
18 };
19 set<node,cmp> refer;
20 int solve(node pos)
21 {
22     set<node,cmp>::iterator p=refer.find(pos);
23     if(p==refer.end()) return 0;
24     else
25     {
26         int val=p->val;
27         refer.erase(p);
28         return solve(node(pos.r+1,pos.c,pos.val))+solve(node(pos.r-1,pos.c,pos.val))+solve(node(pos.r,pos.c+1,pos.val))+solve(node(pos.r,pos.c-1,pos.val))+val;
29     }
30 }
31 int main()
32 {
33     int n;
34     while(true)
35     {
36        scanf("%d",&n);
37        if(!n) break;
38        while(n--)
39        {
40           int r,c,v;
41           scanf("%d%d%d",&r,&c,&v);
42           refer.insert(node(r,c,v));
43        }
44        int res=0;
45        while(!refer.empty())
46        {
47           int ans=solve(*(refer.begin()));
48           if(ans>res) res=ans;
49        }
50        printf("%d\n",res);
51     }
52     return 0;
53 }
54

yzhw 2010-10-15 16:15 发表评论

pku Left labyrinths DFS网格图搜索-注意这种非优先路搜索判重一定要带方向向量

yzhw — Fri, 15 Oct 2010 08:09:00 GMT

题目意思很简单，一个迷宫，问是否能够从入口处进入，在岔道口处向左拐，问采取这种策略能够走到中心。
由于这里不是全DFS，而是具有某种优先级顺序，在这里，优先级是指一直向左拐。判重的时候不能仅仅判断这个格子是否走过，还要加上方向向量，即从什么方向走入这个格子的。

  1 # include <iostream>
  2 # include <cstring>
  3 # include <cstdio>
  4 using namespace std;
  5 char map[105][105];
  6 bool used[105][105][4];//方向：0-向上 1-向右 2-向下 3-向左
  7 int n,m;
  8 int sr=-1,sc=-1;
  9 inline bool chk(int r,int c)
10 {
11    if(r+1<n&&r-1>=0&&map[r+1][c]=='#'&&map[r-1][c]=='#') return true;
12    else if(c+1<m&&c-1>=0&&map[r][c-1]=='#'&&map[r][c+1]=='#') return true;
13    else return false;
14 }
15 inline int encode(int r,int c,int dir)
16 {
17      return (((r<<7)|c)<<2)|dir;
18 }
19 inline bool legal(int r,int c)
20 {
21    if(r>=0&&r<n&&c>=0&&c<m&&map[r][c]=='.') return true;
22    else return false;
23 }
24 void findstart(int r,int c)
25 {
26    if(r>=n||r<0||c>=m||c<0||map[r][c]!='.') return;
27    if(chk(r,c))
28    {
29       sr=r;
30       sc=c;
31       return;
32    }
33    map[r][c]=' ';
34    findstart(r+1,c);
35    findstart(r-1,c);
36    findstart(r,c+1);
37    findstart(r,c-1);
38 }
39 bool dfs(int r,int c,int dir)
40 {
41   // printf("%d %d %d\n",r,c,dir);
42   // system("pause");
43    if(used[r][c][dir]) return false;
44    else
45    {
46        if(legal(r,c)&&legal(r+1,c)&&legal(r,c+1)&&legal(r+1,c+1)||
47           legal(r,c-1)&&legal(r,c)&&legal(r+1,c-1)&&legal(r+1,c)||
48           legal(r-1,c)&&legal(r,c)&&legal(r-1,c+1)&&legal(r,c+1)||
49           legal(r-1,c-1)&&legal(r-1,c)&&legal(r,c-1)&&legal(r,c))
50           return true;
51        used[r][c][dir]=true;
52        switch(dir)
53        {
54          case 0:
55               if(legal(r,c-1)) return dfs(r,c-1,3);
56               else if(legal(r-1,c)) return dfs(r-1,c,0);
57               else if(legal(r,c+1)) return dfs(r,c+1,1);
58               break;
59          case 1:
60               if(legal(r-1,c)) return dfs(r-1,c,0);
61               else if(legal(r,c+1)) return dfs(r,c+1,1);
62               else if(legal(r+1,c)) return dfs(r+1,c,2);
63               break;
64          case 2:
65               if(legal(r,c+1)) return dfs(r,c+1,1);
66               else if(legal(r+1,c)) return dfs(r+1,c,2);
67               else if(legal(r,c-1)) return dfs(r,c-1,3);
68               break;
69          case 3:
70               if(legal(r+1,c)) return dfs(r+1,c,2);
71               else if(legal(r,c-1)) return dfs(r,c-1,3);
72               else if(legal(r-1,c)) return dfs(r-1,c,0);
73               break;
74        } ;
75        return false;
76    }
77
78 }
79 int main()
80 {
81     //int n,m;
82     scanf("%d%d",&n,&m);
83     for(int i=0;i<n;i++)
84        scanf("%s",map[i]);
85     for(int i=0;i<n;i++)
86     {
87         if(map[i][0]=='.')
88            findstart(i,0);
89         if(map[i][m-1]=='.')
90            findstart(i,m-1);
91     }
92     for(int i=0;i<m;i++)
93     {
94         if(map[0][i]=='.')
95            findstart(0,i);
96         if(map[n-1][i]=='.')
97            findstart(n-1,i);
98     }
99   //  for(int i=0;i100     //  printf("%s\n",map[i]);
101   //  system("pause");
102     memset(used,false,sizeof(used));
103     if(sr+1<n&&sr-1>=0&&map[sr+1][sc]=='#'&&map[sr-1][sc]=='#')
104        if(sc+1>=m||map[sr][sc+1]==' ')
105           printf("%s\n",dfs(sr,sc,3)?"YES":"NO");
106        else
107           printf("%s\n",dfs(sr,sc,1)?"YES":"NO");
108     else
109        if(sr+1>=n||map[sr+1][sc]==' ')
110           printf("%s\n",dfs(sr,sc,0)?"YES":"NO");
111        else
112           printf("%s\n",dfs(sr,sc,2)?"YES":"NO");
113     //system("pause");
114     return 0;
115
116 }
117

yzhw 2010-10-15 16:09 发表评论

PKU 3854 搜索、然后进行类似拓扑排序的处理

yzhw — Thu, 14 Oct 2010 10:13:00 GMT

这题大意是一堆积木，抽掉某一块后会使得上面的积木崩溃（当上面的积木仅仅与抽去的部分相邻），问抽去哪块积木会使得崩塌的总积木数最多
这题做法是先将积木处理成图的节点，然后如果假设底下的积木i与上面的积木j直接相邻面为k，则将i与j连接条权值为k的边，然后针对每一块积木枚举求崩溃的总块数，这里用类似拓扑排序算法的处理，将每个节点底面与其他面的接触面数作为该节点的“入度”

1# include <iostream>
2using namespace std;
3# include <cstdio>
4# include <map>
5# include <cstring>
6# include <vector>
7# include <queue>
8char g[101][101];
9int id[101][101];
10int n,m,c;
11# define max(a,b) ((a)>(b)?(a):(b))
12struct
13{
14    int r,c,len;
15}block[10001];
16int main()
17{
18    while(true)
19    {
20        scanf("%d%d",&n,&m);
21        if(!n&&!m) break;
22        for(int i=0;i<n;i++)
23            scanf("%s",g[i]);
24        c=0;
25        for(int i=0;i<n;i++)
26            for(int j=0;j<m;)
27            {
28                if(g[i][j]=='0')
29                {
30                    j++;
31                    continue;
32                }
33                block[c].r=i;
34                block[c].c=j;
35                block[c].len=g[i][j]-'0';
36                for(int k=j;k<block[c].len+j;k++)
37                     id[i][k]=c;
38                j+=block[c++].len;
39            }
40        int degree[10001];
41        int res=0;
42        queue<int> q;
43        int stddegree[10001];
44        for(int i=0;i<c;i++)
45        {
46            stddegree[i]=block[i].len;
47            if(block[i].r+1!=n)
48                for(int j=block[i].c;j<block[i].c+block[i].len;j++)
49                    if(g[block[i].r+1][j]=='0')
50                        stddegree[i]--;
51        }
52        for(int i=0;i<c;i++)
53        {
54
55            int ans=0;
56            memcpy(degree,stddegree,sizeof(degree));
57            q.push(i);
58            while(!q.empty())
59            {
60                int top=q.front();
61                q.pop();
62                ans+=block[top].len;
63                if(block[top].r!=0)
64                    for(int j=block[top].c;j<block[top].c+block[top].len;j++)
65                    if(g[block[top].r-1][j])
66                    {
67                        degree[id[block[top].r-1][j]]--;
68                        if(!degree[id[block[top].r-1][j]])
69                            q.push(id[block[top].r-1][j]);
70                    }
71            }
72            res=max(res,ans);
73        }
74        printf("%d\n",res);
75
76
77    }
78    return 0;
79}
80
81
82

yzhw 2010-10-14 18:13 发表评论

PKU1137 The New Villa 裸BFS+位压缩判重

yzhw — Tue, 12 Oct 2010 13:28:00 GMT

http://poj.org/problem?id=1137
题目是说，一个人要从1号房间走到N号房间，每间房间里可能有其他房间灯的开关，这个人只能走到灯开着的房间里。开始时1号房间灯开着，其他房间灯都没开，问从1号房间走到N号房间并且仅仅保留N号房间的灯至少需要多少步。
这道题没有SPJ，非常的恶心，走的顺序应该是如果能到别的房间先到别的房间，否则如果能关灯先关灯，然后再开灯，所有步骤内的顺序按照节点编号从小到大处理。BFS很好办，用类似A*的牛们可能就悲剧点了~其实也好控制，在优先级里面加入第二关键字就可以了。
判重的时候还是用位压缩。
有点要注意是用printf将浮点数转化为整数时一定要强制转化下，否则也可以用%.0f输出

  1 # include <iostream>
  2 # include <cstdio>
  3 # include <vector>
  4 # include <cmath>
  5 # include <cstring>
  6 # include <algorithm>
  7 bool used[50000];
  8 int q[50000][3],s,e;
  9 # define N 12
10 using namespace std;
11 vector<int> g[N];
12 vector<int> l[N];
13 void print(int res)
14 {
15
16               if(q[res][2]==-1) return;
17               print(q[res][2]);
18               int ps=q[q[res][2]][0]&((1<<11)-1),ns=q[res][0]&((1<<11)-1);
19               if(ps>ns)
20                 printf("- Switch off light in room %.0f.\n",log(ps-ns)/log(2.0)+1e-6);//这里输出浮点数注意！
21               else if(ps<ns)
22                 printf("- Switch on light in room %.0f.\n",log(ns-ps)/log(2)+1e-6);
23               else
24                 printf("- Move to room %d.\n",q[res][0]>>11);
25 }
26 int main()
27 {
28   // freopen("ans.txt","w",stdout);
29     int n,d,s,c=1;
30     while(true)
31     {
32        scanf("%d%d%d",&n,&d,&s);
33        if(!n&&!d&&!s) break;
34        for(int i=1;i<=n;i++)
35        {
36           g[i].clear();
37           l[i].clear();
38
39        }
40        while(d--)
41        {
42           int u,v;
43           scanf("%d%d",&u,&v);
44           g[u].push_back(v);
45           g[v].push_back(u);
46        }
47        while(s--)
48        {
49           int u,v;
50           scanf("%d%d",&u,&v);
51           l[u].push_back(v);
52        }
53        for(int i=1;i<=n;i++)
54        {
55          sort(g[i].begin(),g[i].end());
56          sort(l[i].begin(),l[i].end());
57        }
58        s=e=-1;
59        e=0;
60        q[e][0]=(1<<11)|(1<<1);
61        q[e][1]=0;
62        q[e][2]=-1;
63        int res=-1;
64        memset(used,false,sizeof(used));
65        used[q[e][0]]=true;
66        while(s!=e&&res==-1)
67        {
68           int pos=q[++s][0],len=q[s][1];
69           if(pos==((n<<11)|(1<<n))) res=s;
70           int sta=pos&((1<<11)-1);
71           pos>>=11;
72           for(int i=0;i<g[pos].size();i++)
73             if(!used[(g[pos][i]<<11)|sta]&&(sta|(1<<g[pos][i]))==sta)
74             {
75                used[(g[pos][i]<<11)|sta]=true;
76                q[++e][0]=(g[pos][i]<<11)|sta;
77                q[e][1]=len+1;
78                q[e][2]=s;
79             }
80           for(int i=0;i<l[pos].size();i++)
81             if(l[pos][i]!=pos&&(sta|(1<<l[pos][i]))==sta&&!used[(pos<<11)|(sta-(1<<l[pos][i]))])
82             {
83               used[(pos<<11)|(sta-(1<<l[pos][i]))]=true;
84               q[++e][0]=(pos<<11)|(sta-(1<<l[pos][i]));
85               q[e][1]=len+1;
86               q[e][2]=s;
87             }
88           for(int i=0;i<l[pos].size();i++)
89             if((sta|(1<<l[pos][i]))!=sta&&!used[(pos<<11)|(sta|(1<<l[pos][i]))])
90             {
91               used[(pos<<11)|(sta|(1<<l[pos][i]))]=true;
92               q[++e][0]=(pos<<11)|(sta|(1<<l[pos][i]));
93               q[e][1]=len+1;
94               q[e][2]=s;
95             }
96
97        }
98        printf("Villa #%d\n",c++);
99        if(res==-1) printf("The problem cannot be solved.\n\n");
100        else
101        {
102            printf("The problem can be solved in %d steps:\n",q[res][1]);
103            print(res);
104            printf("\n");
105        }
106
107     }
108     return 0;
109 }
110

yzhw 2010-10-12 21:28 发表评论