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

pku3908 并查集的一点小变通

yzhw — Wed, 22 Feb 2012 07:58:00 GMT

题目大意这样，给出一些节点，给出3种命令：
1、将a,b联通
2、查询a,b的联通状况
3、删除链接a的边。（如果之前a,c通过b联通，那么删除b的联通关系后a,c仍然认为联通）
1，2两种操作乍一看MS是并查集，但是第三种状况让人很恼火，尤其是想用路径压缩技巧的时候。那么，我们不妨转换下思路，删除a的联通关系可以认为将a节点重标号，把之前那个a节点认为是虚拟节点，这样联通性啥的都好保证了。详细请看代码：

Source Code

Problem: 3908		User: yzhw
Memory: 1096K		Time: 47MS
Language: G++		Result: Accepted

Source Code

# include 
# define N 100000
using namespace std;
int set[N],id[N];
int find(int pos)
{
	if(set[pos]==pos) return pos;
	else return set[pos]=find(set[pos]);
}
void uni(int a,int b)
{
	set[find(a)]=find(b);
}
int main()
{
	int num;
	while(scanf("%d",&num)!=EOF)
	{
		int c=num+1,n1=0,n2=0;
		for(int i=1;i<N;i++) set[i]=i;
		for(int i=1;i<=num;i++) id[i]=i;
		char jud[5];
		while(scanf("%s",jud)&&*jud!='e')
		{
			int a,b;
			switch(*jud)
			{
			case 'c':
				scanf("%d%d",&a,&b);
				uni(id[a],id[b]);
				break;
			case 'd':
				scanf("%d",&a);
				id[a]=c++;
				break;
			case 'q':
				scanf("%d%d",&a,&b);
				if(find(id[a])==find(id[b])) n1++;
				else n2++;
				break;
			};

		}
		printf("%d , %d\n",n1,n2);
	}
	return 0;
}

yzhw 2012-02-22 15:58 发表评论

pku 3943 Digits on the Floor 并查集的活用（重点）+数字识别

yzhw — Sat, 14 Jan 2012 11:57:00 GMT

题意很简单，给出一些线段，组成一些数字，保持数字连接点的联通关系不变（就说是图的逻辑结构不变吧），并且保证没有相交。要求识别数字。
首先这题，涉及到并查集的运用。开始犯了个很糊涂的错误，本题新加上一条线段可能造成2种情况
1、A - C，新加线为C，就是把C连接到某个树枝上
2、A-C-B，这种情况考虑漏了，就是通过C这个线把俩个不连通的集合给打通了
具体代码应该是这样
for(int j=0;j if(find(now)!=find(j)&&cross(now,j))
set[find(now)]=find(j);
开始糊涂蛋的写成了
for(int j=0;j if(cross(now,j))
set[now]=find(j),break;
这个就是只考虑了第一种情况。

关于数字识别的问题就好办多了，主要根据部分相交和点相交的数目以及联通集中线段的数目来判断数字（5和2还要根据叉积再来弄下），这题受益最深的就是并查集那里，容易犯的错误。

代码如下：

1 Source Code
  2
  3 Problem: 3943        User: yzhw
  4 Memory: 656K        Time: 188MS
  5 Language: G++        Result: Accepted
  6 Source Code
  7 # include
  8 # include
  9 # include
10 # include
11 using namespace std;
12 # define N 1005
13 # define min(a,b) ((a)<(b)?(a):(b))
14 # define max(a,b) ((a)>(b)?(a):(b))
15 struct line
16 {
17     int x1,y1,x2,y2;
18 }l[N];
19 bool in(int x,int y,const line &pos)
20 {
21     if(x>=min(pos.x1,pos.x2)&&x<=max(pos.x1,pos.x2)&&
22        y>=min(pos.y1,pos.y2)&&y<=max(pos.y1,pos.y2)&&
23        (pos.y2-pos.y1)*(pos.x2-x)==(pos.x2-pos.x1)*(pos.y2-y))
24        return true;
25     else return false;
26 }
27 int cross(const line &a,const line &b)
28 {
29     if(a.x1==b.x1&&a.y1==b.y1||
30         a.x2==b.x1&&a.y2==b.y1||
31         a.x1==b.x2&&a.y1==b.y2||
32         a.x2==b.x2&&a.y2==b.y2) return 1;
33     else if(in(a.x1,a.y1,b)||in(a.x2,a.y2,b)||in(b.x1,b.y1,a)||in(b.x2,b.y2,a)) return 2;
34     else return 0;
35 }
36 int cross(int x1,int y1,int x2,int y2)
37 {
38     return x1*y2-x2*y1;
39 }
40 struct node
41 {
42     vector data;
43     int type() const
44     {
45         int num[3]={0,0,0};
46         for(int i=0;i 47             for(int j=i+1;j 48                 num[cross(data[i],data[j])]++;
49         if(num[1]==4&&num[2]==0)
50         {
51             if(data.size()==4) return 0;
52             else
53             {
54                 int target=-1,x1,y1,x2,y2;
55                 for(int i=0;i 56                 {
57                     bool flag=true;
58                     for(int j=0;j 59                         if(j!=i&&(data[i].x1==data[j].x1&&data[i].y1==data[j].y1||data[i].x1==data[j].x2&&data[i].y1==data[j].y2))
60                             flag=false;
61                     if(flag)
62                     {
63                         target=i;
64                         x1=data[i].x2,y1=data[i].y2;
65                         x2=data[i].x1,y2=data[i].y1;
66                         break;
67                     }
68                     flag=true;
69                     for(int j=0;j 70                         if(j!=i&&(data[i].x2==data[j].x1&&data[i].y2==data[j].y1||data[i].x2==data[j].x2&&data[i].y2==data[j].y2))
71                             flag=false;
72                     if(flag)
73                     {
74                         target=i;
75                         x1=data[i].x1,y1=data[i].y1;
76                         x2=data[i].x2,y2=data[i].y2;
77                         break;
78                     }
79                 }
80                 for(int i=0;i 81                     if(i!=target)
82                     {
83                         if(data[i].x1==x1&&data[i].y1==y1)
84                             return cross(data[i].x2-data[i].x1,data[i].y2-data[i].y1,x1-x2,y1-y2)<0?5:2;
85                         else if(data[i].x2==x1&&data[i].y2==y1)
86                             return cross(data[i].x1-data[i].x2,data[i].y1-data[i].y2,x1-x2,y1-y2)<0?5:2;
87                     }
88             }
89             printf("wa!\n");
90             while(true);
91         }
92         else if(num[1]==0&&num[2]==0)
93             return 1;
94         else if(num[1]==4&&num[2]==0)
95             return 2;
96         else if(num[1]==2&&num[2]==1)
97             return 3;
98         else if(num[1]==1&&num[2]==1)
99             return 4;
100         else if(num[1]==4&&num[2]==1)
101             return 6;
102         else if(num[1]==2&&num[2]==0)
103             return 7;
104         else if(num[1]==4&&num[2]==2)
105             return 8;
106         else if(num[1]==3&&num[2]==1)
107             return 9;
108     }
109 };
110 map<int,node> data;
111 int n,set[N],ans[10];
112 int find(int pos)
113 {
114     if(set[pos]==pos) return pos;
115     else return set[pos]=find(set[pos]);
116 }
117 int main()
118 {
119     while(scanf("%d",&n)!=EOF&&n)
120     {
121         data.clear();
122         memset(ans,0,sizeof(ans));
123         for(int i=0;i124         {
125             set[i]=i;
126             scanf("%d%d%d%d",&l[i].x1,&l[i].y1,&l[i].x2,&l[i].y2);
127             for(int j=0;j128                 if(cross(l[i],l[j])&&find(i)!=find(j))
129                     set[find(i)]=find(j);
130         }
131         for(int i=0;i132             data[find(i)].data.push_back(l[i]);
133         for(map<int,node>::iterator i=data.begin();i!=data.end();i++)
134             ans[i->second.type()]++;
135         printf("%d",ans[0]);
136         for(int i=1;i<10;i++)
137             printf(" %d",ans[i]);
138         printf("\n");
139     }
140     return 0;
141 }

yzhw 2012-01-14 19:57 发表评论

2010 天津赛区G hdu 3726 splay

yzhw — Fri, 30 Sep 2011 00:51:00 GMT

摘要: 哎，一道裸splay的题目，网上竟然木有解题报告。我第一次写splay，犯了很多很多NC的错误。。调了有一个下午，最后写了个测试模块+生成了随机数据，才发现错误。说说我的失误吧。。1、首先zig zag实现的时候一定要配对，不能乱，加个儿子节点就要把儿子节点的父亲节点同时初始化好2、新加入节点的size域及其祖先的size域名不用调整，会在splay过程中自动修正完毕3、千万别要试图将一颗子树的根... 阅读全文

yzhw 2011-09-30 08:51 发表评论

2010 ICPC天津赛区 J hdu 3727 划分树的理解

yzhw — Fri, 30 Sep 2011 00:44:00 GMT

很久不写划分树了，果然各种NC错误
按照我的理解，划分树即一个线段树（用来确定数组下标和层次）以及一个log2(n)*n的数组，来记录划分信息
这题实现4个操作：
1、插入
按照划分树的定义，如果小于有序表中中间节点的值，就递归插入左子树，否则递归插入右子树。更新当前区间段的划分信息（无非就是往后计算一个）
2、询问s,e区间第k小数
查询s,e区间里面划分到左子树的个数i，如果i>=k，那么显然递归到左子树查询，否则就是递归到右子树查询k-i小的数。注意！这里要重新定位左子树和右子树中的区间，由于是闭区间，那么做端点为s+sum(s-1),右端点为s+sum(e)-1，这个减一丢了。。调了我半天。。哎。。以前写都是左闭右开区间的，结果习惯了。。
3、查询值为k的数的位次
这个需要一个辅助数组，记录值为k的数插在最顶层区间的哪个位置了。这个办好后，就容易了，如果数被划分到了左子树，那么递归查询左子树，否则返回递归查询右子树的值加上当前区间被划分到左子树的个数
4、查询rank k的数
同样是这样，如果当前区间被划分到左子树的个数小于等于k，那么递归查询左子树，否则递归查询右子树中rank为k-左子树的size。
大概思想就是这样了，实现有很多细节，比如说假设p==区间左端点（左区间木有数），那么算sum(p-1)的时候就要特判下了。我喜欢用三元式，很方便。

代码
# include
# include
# include
using namespace std;
# define N 100005
int arr[20][N];
struct node
{
   int s,e,layer;
   int c;
}st[4*N];
int q[500000][4],c;
int remap[N],position[N];
map<int,int> refer;
void init(int s,int e,int layer,int pos=1)
{
    st[pos].s=s;st[pos].e=e;
    st[pos].layer=layer;
    st[pos].c=st[pos].s;
    if(s!=e) init(s,(s+e)/2,layer+1,pos<<1),init((s+e)/2+1,e,layer+1,(pos<<1)+1);
}
void insert(int value,int pos=1)
{
     if(st[pos].s==st[pos].e)
        arr[st[pos].layer][st[pos].c++]=value;
     else
     {
         if(value<=(st[pos].s+st[pos].e)/2)
         {
             arr[st[pos].layer][st[pos].c]=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])+1;
             st[pos].c++;
             insert(value,pos<<1);
         }
         else
         {
             arr[st[pos].layer][st[pos].c]=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1]);
             st[pos].c++;
             insert(value,(pos<<1)+1);
         }
     }
}
int q1(int s,int t,int k,int pos=1)
{
    if(st[pos].s==st[pos].e)
        return remap[arr[st[pos].layer][st[pos].s]];
    else
    {
        if(arr[st[pos].layer][t]-(s==st[pos].s?0:arr[st[pos].layer][s-1])>=k)//left
            return q1(st[pos].s+(s==st[pos].s?0:arr[st[pos].layer][s-1]),st[pos].s+arr[st[pos].layer][t]-1,k,pos<<1);
        else//right
        {
            k-=arr[st[pos].layer][t]-(s==st[pos].s?0:arr[st[pos].layer][s-1]);
            return q1((st[pos].s+st[pos].e)/2+1+s-1-st[pos].s+1-(s==st[pos].s?0:arr[st[pos].layer][s-1]),(st[pos].s+st[pos].e)/2+1+t-st[pos].s+1-arr[st[pos].layer][t]-1,k,(pos<<1)+1);
        }
    }
}
int q2(int s,int pos=1)
{
    if(st[pos].s==st[pos].e) return 1;
    else if(arr[st[pos].layer][s]-(s==st[pos].s?0:arr[st[pos].layer][s-1]))
      return q2(st[pos].s+arr[st[pos].layer][s]-1,pos<<1);
    else
      return (st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])+q2((st[pos].s+st[pos].e)/2+1+s-st[pos].s+1-arr[st[pos].layer][s]-1,(pos<<1)+1);
}
int q3(int k,int pos=1)
{
    if(st[pos].s==st[pos].e) return remap[arr[st[pos].layer][st[pos].s]];
    else if(k<=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])) return q3(k,pos<<1);
    else return q3(k-(st[pos].s==st[pos].c?0:arr[st[pos].layer][st[pos].c-1]),(pos<<1)+1);
}
int main()
{
    int n,test=1;
    while(scanf("%d",&n)!=EOF)
    {
       refer.clear();c=1;
       memset(arr,0,sizeof(arr));
       for(int i=0;i<n;i++)
       {
           char tmp[12];
           scanf("%s",tmp);
           if(*tmp=='I')
             q[i][0]=0;
           else q[i][0]=tmp[6]-48;
           switch(q[i][0])
           {
           case 0:
                scanf("%d",&q[i][1]);
                refer[q[i][1]]=0;
                break;
           case 1:
                scanf("%d%d%d",&q[i][1],&q[i][2],&q[i][3]);
                break;
           default:
                scanf("%d",&q[i][1]);
                break;
           };
       }
       for(map<int,int>::iterator i=refer.begin();i!=refer.end();i++)
         remap[c]=i->first,i->second=c++;
       init(1,c-1,0);
       long long t[4]={0,0,0,0};
       int now=1;
       for(int i=0;i<n;i++)
         switch(q[i][0])
         {
           case 0:
                insert(refer[q[i][1]]);
                position[refer[q[i][1]]]=now++;
                break;
           case 1:
                t[1]+=q1(q[i][1],q[i][2],q[i][3]);
                break;
           case 2:
                t[2]+=q2(position[refer[q[i][1]]]);
                break;
           case 3:
                t[3]+=q3(q[i][1]);
                break;
         };
       printf("Case %d:\n%I64d\n%I64d\n%I64d\n",test++,t[1],t[2],t[3]);
    }
    return 0;
}

yzhw 2011-09-30 08:44 发表评论

pku 3225 区间我对线段树延迟标记的一些理解

yzhw — Fri, 09 Sep 2011 01:31:00 GMT

摘要: 这题网上结题报告应该很多了，我也不想多写什么，但是写完这题后，我对延迟标记的更新策略有了更新的理解这题节点的结构应该算复杂的了 Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->1 struct tree... 阅读全文

yzhw 2011-09-09 09:31 发表评论

pku1916 Rat Attack 动态统计之经典好题

yzhw — Mon, 04 Apr 2011 14:32:00 GMT

题意

在管道的焦点处有N个种群数目为Pi的鼠群，N<20000，现在要在某个焦点处放一个炸弹，炸弹效力范围是以炸弹为中点的2d*2d的矩形。问炸弹放在哪里可以炸死最多的老鼠，如果有重复则优先保证X坐标最小，如果还有重复就Y坐标最小。
解法
这种题目一般是采用X扫描线+平衡树/树状数组统计的方法。但是这题由于还有第二和第三优先级，我们必须扫描线移动一下就统计一下，不能等到扫描线距离达到2d再统计，然后小x坐标就是后扫描线坐标减去d。用平衡树/树状数组统计时也要注意这个问题。详细情况见代码（我依然很猥琐的用了STL MAP）
PS，好不容易一题在poj rank进前3，不容易啊。。

1# include <cstdio>
2# include <map>
3# include <algorithm>
4using namespace std;
5struct node
6{
7    int x,y,num;
8    bool operator<(const node &pos) const
9    {
10        return x<pos.x;
11    }
12}data[20005];
13int d,n;
14map<int,int> refer;
15void calbest(int nx,int &best,int &x,int &y)
16{
17    map<int,int>::iterator s=refer.begin(),e=refer.begin();
18    int total=0,last=e->first;
19    while(e!=refer.end())
20    {
21        while(e!=refer.end()&&e->first<=s->first+2*d)
22        {
23            total+=e->second;
24            last=e->first;
25            e++;
26        }
27        if(total>best||total==best&&nx-d<x||total==best&&nx-d==x&&last-d<y)
28            best=total,x=nx-d,y=last-d;
29        total-=s->second;
30        s++;
31    }
32}
33int main()
34{
35    //freopen("ans.txt","w",stdout);
36    int test;
37    scanf("%d",&test);
38    while(test--)
39    {
40        scanf("%d%d",&d,&n);
41        for(int i=0;i<n;i++)
42            scanf("%d%d%d",&data[i].x,&data[i].y,&data[i].num);
43        sort(data,data+n);
44        int s=0,e=0;
45        refer.clear();
46        int best=-1,y,x;
47        while(e<n)
48        {
49            int tmp;
50            while(true)
51            {
52                if(e>=n||data[e].x-data[s].x>2*d) break;
53                tmp=data[e].x;
54                while(e<n&&data[e].x==tmp)
55                    {
56                        refer[data[e].y]+=data[e].num;
57                        e++;
58                    }
59                calbest(data[e-1].x,best,x,y);
60            }
61            tmp=data[s].x;
62            while(data[s].x==tmp&&s<n)
63            {
64                refer[data[s].y]-=data[s].num;
65                if(refer[data[s].y]==0) refer.erase(data[s].y);
66                s++;
67            }
68        }
69        printf("%d %d %d\n",x>=0?x:0,y>=0?y:0,best);
70
71    }
72    return 0;
73}
74
75

yzhw 2011-04-04 22:32 发表评论

pku3168 Barn Expansion 排序+区间重叠判断

yzhw — Tue, 01 Mar 2011 18:10:00 GMT

MS好久不写blog了，现在好忙，又是GRE，又是考研，又是ACM。。蛋疼
言归正传
题意:
给出一些长方形，不重叠，但可以擦边或擦角。问有多少个长方形是完全不和别的长方形沾边的

给力条件：不重叠

方法：经典的排序+区间合并

代码：

1 # include <cstdio>
2 # include <cstring>
3 # include <cstdlib>
4 # define max(a,b) ((a)>(b)?(a):(b))
5 using namespace std;
6 struct line
7 {
8    int s,e,p,id;
9 }tmp[60000];
10 int cmp(const void *a,const void *b)
11 {
12     line *aa=(line *)a,*bb=(line *)b;
13     if(aa->p!=bb->p) return aa->p-bb->p;
14     else return aa->s-bb->s;
15 }
16 int data[30000][4],n;
17 bool used[30000];
18 void solve()
19 {
20     int end=tmp[0].e,last=0;
21     for(int i=1;i<2*n;i++)
22       if(tmp[i].p==tmp[i-1].p&&tmp[i].s<=end)
23          end=max(end,tmp[i].e);
24       else
25       {
26          if(last!=i-1)
27           for(int j=last;j<i;j++)
28             used[tmp[j].id]=false;
29           end=tmp[i].e;
30           last=i;
31       }
32      if(last!=2*n-1)
33      for(int j=last;j<2*n;j++)
34         used[tmp[j].id]=false;
35 }
36 int main()
37 {
38     scanf("%d",&n);
39     memset(used,true,sizeof(used));
40     for(int i=0;i<n;i++)
41       scanf("%d%d%d%d",&data[i][0],&data[i][1],&data[i][2],&data[i][3]);
42     for(int i=0;i<n;i++)
43     {
44        tmp[2*i].s=data[i][0];
45        tmp[2*i].e=data[i][2];
46        tmp[2*i].p=data[i][1];
47        tmp[2*i].id=i;
48        tmp[2*i+1]=tmp[2*i];
49        tmp[2*i+1].p=data[i][3];
50     }
51     qsort(tmp,2*n,sizeof(line),cmp);
52    /* printf("\n");
53     for(int i=0;i<2*n;i++)
54       printf("%d %d %d %d\n",tmp[i].id,tmp[i].p,tmp[i].s,tmp[i].e);
55     printf("\n");*/
56     solve();
57     for(int i=0;i<n;i++)
58     {
59        tmp[2*i].s=data[i][1];
60        tmp[2*i].e=data[i][3];
61        tmp[2*i].p=data[i][0];
62        tmp[2*i].id=i;
63        tmp[2*i+1]=tmp[2*i];
64        tmp[2*i+1].p=data[i][2];
65     }
66     qsort(tmp,2*n,sizeof(line),cmp);
67    /* for(int i=0;i<2*n;i++)
68       printf("%d %d %d %d\n",tmp[i].id,tmp[i].p,tmp[i].s,tmp[i].e);
69     printf("\n");*/
70     solve();
71     int c=0;
72     for(int i=0;i<n;i++)
73       c+=used[i];
74     printf("%d\n",c);
75     //system("pause");
76     return 0;
77 }
78

yzhw 2011-03-02 02:10 发表评论

pku1944 Fiber Communications 图论好题！总体上的观察，算法不难

yzhw — Fri, 04 Feb 2011 17:20:00 GMT

题意：
n个节点组成一个环，相邻节点间可以连边，有m对点间需要通讯，问最少要构造多少通讯线路

解答：
首先，要明确一点，a,b之间要通讯，只能有两种通讯线路[1,a),[a,n)，还有一个重要条件就是最多只需要构建n-1条边能将所有点联通。这样就只要枚举断电点，所有对通讯节点中的连接方式就都确定了，因为连接路径是互补的。断开一个点，一条路径就被砍断了，只能选择另外一条。然后统计覆盖的点的时候建议使用树状数组，树状数组表示这种左开右闭的区间是很给力的。左端点+1，右端点-1，复杂度n2logn。

代码

1 # include <cstdio>
2 # include <utility>
3 # include <functional>
4 # include <iostream>
5 # include <algorithm>
6 # include <cstring>
7 # define lowbit(a) (a&-a)
8 using namespace std;
9 int arr[1005],n,m;
10 pair<int,int>data[10005];
11 void add(int p,int num)
12 {
13    while(p<=n)
14       arr[p]+=num,p+=lowbit(p);
15 }
16 int sum(int p)
17 {
18     int res=0;
19     while(p>0)
20       res+=arr[p],p-=lowbit(p);
21     return res;
22 }
23 int main()
24 {
25     scanf("%d%d",&n,&m);
26     for(int i=0;i<m;i++)
27     {
28       scanf("%d%d",&data[i].first,&data[i].second);
29       if(data[i].first>data[i].second)
30         swap(data[i].first,data[i].second);
31     }
32     int ans=0xfffffff;
33     for(int i=1;i<=n;i++)
34     {
35         memset(arr,0,sizeof(arr));
36         for(int j=0;j<m;j++)
37             if(data[j].first<=i&&data[j].second>i)
38                 add(1,1),add(data[j].first,-1),add(data[j].second,1);
39             else
40                 add(data[j].first,1),add(data[j].second,-1);
41         int res=0;
42         for(int j=1;j<=n;j++)
43            if(sum(j)>0)
44                res++;
45         if(res<ans) ans=res;
46     }
47     printf("%d\n",ans);
48     return 0;
49 }

yzhw 2011-02-05 01:20 发表评论

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

pku2902 Intercepting Missiles 线段树+离散化+二分图匹配，注意C++短路

yzhw — Mon, 31 Jan 2011 10:35:00 GMT

摘要: 题意：有b个炸弹，p个飞机，平行于x轴飞行，地面部署了m个导弹，只能垂直打。知道0时刻炸弹、飞机的坐标，以及导弹的坐标以及炸弹、导弹、飞机的速度，问不打到飞机的情况下最多能拦截多少导弹？给力条件：炸弹被导弹击中后，继续飞行，而导弹立刻消失。飞行物高度均不同有个注意点：注意C++中的短路问题，慎用两个函数相或、与，可能因此一个函数得不到执行，这个在线段树里是很麻烦的。宁可多写一步解法：上次比赛这题死... 阅读全文

yzhw 2011-01-31 18:35 发表评论

pku2894-2903 Tehran 2005 比赛总结

yzhw — Sun, 30 Jan 2011 17:59:00 GMT

摘要: Solved ID Title Ratio(AC/att) Yes Problem A Ancient Keyboard 10... 阅读全文

yzhw 2011-01-31 01:59 发表评论

pku1245-1251 Mid-Central USA 2002 比赛总结

yzhw — Thu, 20 Jan 2011 18:21:00 GMT

摘要: 第二次做比赛，有了viaxl的加入，有点动力 SolvedIDTitle Ratio(AC/att) Yes Problem A Pr... 阅读全文

yzhw 2011-01-21 02:21 发表评论

pku 1235 Galactic Breakup 并查集

yzhw — Thu, 20 Jan 2011 12:44:00 GMT

题意：
一个帝国有N个国家组成，每个国家包括N_i个区域（一个小方格），然后第i个国家在第i月会分离出去。问有多少个月帝国仍然是一个整体。
PS：说道帝国，就想到黄金雄教授在ICPC开幕式上用闽南语讲的（。。。ACM大帝国。。），那发音，拿语言的组织都超级搞笑

思路：
并查集，逆向思维。最后所有的国家应该都是独立的。相当于一个国家一个国家逐月的联合起来。用并查集统计是否当前集合为一个整体即可。暴力的方法没实验过，不过复杂度会高达30^6，(*^__^*) 嘻嘻……，RP好的可以去拼一下～

代码：

1 //============================================================================
2 // Name        : pku1235.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 <vector>
12 #include <algorithm>
13 using namespace std;
14 # define LEFT (data[i][j]%(n*m))
15 int set[30000],n,m,k,l,data[30000][21];
16 bool used[30000];
17 int find(int pos)
18 {
19     if(set[pos]==pos) return pos;
20     else return set[pos]=find(set[pos]);
21 }
22 int main() {
23     int testcase;
24     scanf("%d",&testcase);
25     while(testcase--)
26     {
27         scanf("%d%d%d%d",&n,&m,&k,&l);
28         int total=0,ans=0,c;
29         for(int i=0;i<n*m*k;i++)
30             set[i]=i,used[i]=false;
31         for(int i=0;i<l;i++)
32         {
33             scanf("%d",&data[i][0]);
34             for(int j=1;j<=data[i][0];j++)
35                 scanf("%d",&data[i][j]);
36         }
37         for(int i=l-1;i>=0;i--)
38         {
39             c=0;
40             for(int j=1;j<=data[i][0];j++)
41             {
42                 vector<int> refer;
43                 if(data[i][j]-n*m>=0&&used[data[i][j]-n*m]) refer.push_back(find(data[i][j]-n*m));
44                 if(data[i][j]+n*m<n*m*k&&used[data[i][j]+n*m]) refer.push_back(find(data[i][j]+n*m));
45                 if(LEFT%n!=0&&used[data[i][j]-1]) refer.push_back(find(data[i][j]-1));
46                 if(LEFT%n!=n-1&&used[data[i][j]+1]) refer.push_back(find(data[i][j]+1));
47                 if(LEFT/n!=0&&used[data[i][j]-n]) refer.push_back(find(data[i][j]-n));
48                 if(LEFT/n!=m-1&&used[data[i][j]+n]) refer.push_back(find(data[i][j]+n));
49                 sort(refer.begin(),refer.end());
50                 vector<int>::iterator end=unique(refer.begin(),refer.end());
51                 c+=end-refer.begin();
52                 for(int t=0;t<end-refer.begin();t++)
53                     set[find(refer[t])]=find(data[i][j]);
54                 used[data[i][j]]=true;
55             }
56             total=total+data[i][0]-c;
57             if(total==1) ans++;
58         }
59         printf("%d\n",l-ans);
60     }
61     return 0;
62 }

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

pku 1241 Knockout Tournament 树形DP，很好的题目

yzhw — Wed, 19 Jan 2011 17:44:00 GMT

题意：

看图说话，一棵锦标赛树（具体不描述，看DS书去），问每个队员的最好名次和最坏名次

分析：
求最好名次应该从上向下划分状态，而求最坏名次从下向上划分状态，举个例子吧，看第三排第一个1，它的最坏名次是第四排第一个1的最坏名次加上它的1^n-右孩子的最坏名次-1，而它的最好名次则是第二排第一个1的最好名次，它旁边那个3的最好名次就是3的父节点（1）的最好名次+1，大概明白什么意思了吧？看代码吧～。

代码：

1 # include <cstdio>
2 # include <cstring>
3 using namespace std;
4 # define max(a,b) ((a)>(b)?(a):(b))
5 # define min(a,b) ((a)<(b)?(a):(b))
6 int tree[1024],n;
7 int worst[1024],best[1024],high[1024],low[1024];
8 int main()
9 {
10     while(true)
11     {
12         scanf("%d",&n);
13         if(!n) break;
14         for(int i=1<<n;i<1<<(n+1);i++)
15             tree[i]=1+i-(1<<n),worst[i]=1<<n;
16         for(int t=n-1;t>=0;t--)
17             for(int i=1<<t;i<1<<(t+1);i++)
18             {
19                  scanf("%d",tree+i);
20                  worst[i]=(tree[i]==tree[i<<1]?worst[i<<1]-(1<<n)+worst[(i<<1)+1]:worst[(i<<1)+1]-(1<<n)+worst[i<<1])-1;
21             }
22         best[1]=1;
23         for(int i=2;i<1<<(n+1);i++)
24             best[i]=(tree[i]==tree[i>>1]?best[i>>1]:best[i>>1]+1);
25         for(int i=1;i<1<<(n+1);i++)
26             high[i]=low[i]=1<<n;
27         for(int i=1;i<1<<(n+1);i++)
28         {
29             high[tree[i]]=min(high[tree[i]],best[i]);
30             low[tree[i]]=min(low[tree[i]],worst[i]);
31         }
32         scanf("%d",&n);
33         while(n--)
34         {
35             int t;
36             scanf("%d",&t);
37             printf("Player %d can be ranked as high as %d or as low as %d.\n",t,high[t],low[t]);
38         }
39         printf("\n");
40     }
41     return 0;
42 }

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

pku 1231 The Alphabet Game 很好的数据结构题目

yzhw — Sun, 16 Jan 2011 16:55:00 GMT

摘要: 题意是这样：一个格板上写有k*n个字母，第i个字母有k个。然后问能否用贯穿整个方格板的横线和竖线将不同的字母分开。解法：首先，假设我们将k个同一个字母用一个n*m的矩形框框住，这题就转换为这样一个问题：平面上给出一些矩形，能否用用一些水平或竖直线将平面划分开，使得每一个区域中有且仅有一个矩形。下面的想法就有点巧妙，首先，横向的切割与纵向的切割是相互独立的，就是说，无论水平线怎么画与竖直线的安排无关... 阅读全文

yzhw 2011-01-17 00:55 发表评论

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 1214 "Accordian" Patience STL+模拟

yzhw — Thu, 13 Jan 2011 13:28:00 GMT

题意：

你的任务是模拟一种叫「Accordian」的纸牌游戏，他的游戏规则如下：

一副扑克牌有52张牌，首先把纸牌一张一张由左到右排好（不能有重叠，所以共有52堆牌，每堆一张），当某一张牌与他左边那张牌或者左边的第三张牌有「Match」的时候，就把这张牌移到那张牌上面去。在这里两张牌「Match」指的是这两张牌的花色（suit）或者点数（rank）一样。当你做了一个移动之后，要察看是否还可以做其他的移动。在任何时间，只有最上面那张牌可以被移动。如果因为移动一张牌使得产生一个空格（也就是被移动的那堆牌只有一张牌），你必须把右边所有的牌堆往左移一格。如此不断的寻找可移动的牌，直到没有一张牌可以移动游戏就结束了。

在选择可以移动的牌的时候可能有些状况会发生。如果有两张牌都可以移动，你应该要移动最左边的那张牌。当一张牌可以被移动到左边一格，或左边三格的时候，你必须移动到左边三格

解法：
纯模拟，外层用STL set，内层用STL stack，然后就是各种调用，各种迭代器~

代码：

1# include <list>
2# include <vector>
3# include <cstdio>
4# include <algorithm>
5using namespace std;
6list<vector<pair<char,char> > > l;
7int main()
8{
9    vector<pair<char,char> >t;
10    while(true)
11    {
12        char tmp[5];
13        scanf("%s",tmp);
14        if(tmp[0]=='#') break;
15        t.clear();
16        l.clear();
17        t.push_back(pair<char,char>(tmp[0],tmp[1]));
18        l.push_back(t);
19        for(int i=1;i<52;i++)
20        {
21            t.clear();
22            scanf("%s",tmp);
23            t.push_back(pair<char,char>(tmp[0],tmp[1]));
24            l.push_back(t);
25        }
26        while(true)
27        {
28            bool flag=false;
29            for(list<vector<pair<char,char> > >::iterator i=l.begin();i!=l.end()&&!flag;)
30            {
31                int count=0;
32                bool remove=false;
33                list<vector<pair<char,char> > >::iterator i3=i;
34                while(i3!=l.begin()&&count<3)
35                {
36                    count++;
37                    i3--;
38                }
39                if(count==3&&(i3->back().first==i->back().first||i3->back().second==i->back().second))
40                {
41                    i3->push_back(i->back());
42                    i->pop_back();
43                    if(i->empty()) i=l.erase(i),remove=true;
44                    flag=true;
45                }
46                else
47                {
48                    i3=i;
49                    if(i3!=l.begin())
50                    {
51                        i3--;
52                        if(i3->back().first==i->back().first||i3->back().second==i->back().second)
53                        {
54                            i3->push_back(i->back());
55                            i->pop_back();
56                            if(i->empty()) i=l.erase(i),remove=true;
57                            flag=true;
58                        }
59                    }
60                }
61                if(!remove) i++;
62            }
63            if(!flag) break;
64        }
65        printf("%d piles remaining:",l.size());
66        for(list<vector<pair<char,char> > >::iterator i=l.begin();i!=l.end();i++)
67            printf(" %d",i->size());
68        printf("\n");
69    }
70}
71

yzhw 2011-01-13 21:28 发表评论

pku3630 Phone List 字典树+判断前缀经典入门题

yzhw — Tue, 11 Jan 2011 16:11:00 GMT

题意：
给出一堆电话号码，判断是否存在某个号码是另一个号码的前缀

题解：
还是通过字典树，不过判断的时候不能够仅仅判断当前待插入字符串的路径上是否包含结束标记（如果事先对字符转进行了按长短排序就没问题了），而需要记录每个节点包含的路径条数，如果在待插入字符串的尾节点（即结束标记节点上通过的路径数大于1，则说明有路径覆盖了这个节点，即有一个字符转以当前字符串为前缀，故不可能）

代码：

1import java.io.*;
2class Dic_Tree
3{
4    class node
5    {
6        node nxt[]=new node[10];
7        boolean end=false;
8        int count=0;
9    }
10    node head=null;
11    void clear()
12    {
13        head=new node();
14    }
15    boolean insert(String str)
16    {
17        node p=head;
18        for(int i=0;i<str.length();i++)
19        {
20            p.count++;
21            if(p.end) return false;
22            if(p.nxt[str.charAt(i)-48]==null)
23                p.nxt[str.charAt(i)-48]=new node();
24            p=p.nxt[str.charAt(i)-48];
25        }
26        p.count++;
27        if(p.count>1) return false;
28        p.end=true;
29        return true;
30    }
31
32}
33public class Main {
34
35    /**
36     * @param args
37     */
38    static Dic_Tree data=new Dic_Tree();
39    public static void main(String[] args) throws IOException{
40        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
41        int test=Integer.parseInt(in.readLine());
42        while((test--)!=0)
43        {
44            int num=Integer.parseInt(in.readLine());
45            boolean flag=true;
46            data.clear();
47            while((num--)!=0)
48              if(flag)
49              {
50                if(!data.insert(in.readLine())) flag=false;
51              }
52              else
53                  in.readLine();
54            if(flag) System.out.println("YES");
55            else System.out.println("NO");
56
57        }
58
59    }
60
61}
62

yzhw 2011-01-12 00:11 发表评论

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

pku1211 Traffic Lights 简单模拟+堆优化

yzhw — Sun, 09 Jan 2011 12:22:00 GMT

题目说的很乱，我整理一下
所有灯都按绿、橙、红的顺序变化，绿色持续t-5秒，橙色持续5秒，红色持续t秒，第0时刻所有灯都是刚刚变绿。求所有灯再一次变绿的最早时刻

解法：
有一点要明确，所求的最早时刻肯定是所有灯中其中一盏刚刚变绿，否则我们能够找到一个更早的时刻所有灯都是绿的。那么只要枚举所有灯的开始时间，然后再判断此时刻所有灯都是绿色即可。
由于题目要求时刻小于5小时，即使暴力枚举也不过3600*5，再加上判断复杂度，总复杂度为360000*5，应该也能过
当然，可以用堆来优化，这样能够将最坏复杂度至少降低一半

代码：

1# include <cstdio>
2# include <queue>
3# include <cstring>
4using namespace std;
5struct node
6{
7   int i,t;
8   bool operator<(const node &b) const
9   {
10      return t>b.t;
11   }
12   node(int id,int time):i(id),t(time){}
13};
14int loop[101],c,start;
15priority_queue<node> q;
16bool chk(int t)
17{
18   for(int i=0;i<c;i++)
19     if(t%(2*loop[i])>=loop[i]-5) return false;
20   return true;
21}
22void print(int t)
23{
24   printf("%s%d:%s%d:%s%d\n",t/3600<10?"0":"",t/3600,(t%3600)/60<10?"0":"",(t%3600)/60,(t%3600)%60<10?"0":"",(t%3600)%60);
25}
26int main()
27{
28   while(true)
29   {
30      c=0;
31      while(!q.empty()) q.pop();
32      scanf("%d",&loop[c++]);
33      if(!loop[0])
34      {
35        scanf("%d%d",&loop[1],&loop[2]);
36        break;
37      }
38      else
39      {
40          int flag=0;
41          while(loop[c-1])
42             scanf("%d",&loop[c++]);
43          c--;
44          start=0xfffffff;
45          for(int i=0;i<c;i++)
46            if(loop[i]-5<start) start=loop[i]-5;
47          start=0;
48          for(int i=0;i<c;i++)
49            if(2*loop[i]-start<=3600*5) q.push(node(i,2*loop[i]));
50          while(!q.empty()&&!flag)
51          {
52             node top=q.top();
53             q.pop();
54             if(chk(top.t)) flag=top.t;
55             else
56             {
57                 top.t+=2*loop[top.i];
58                 if(top.t-start<=5*3600) q.push(top);
59             }
60          }
61          if(flag) print(flag-start);
62          else printf("Signals fail to synchronise in 5 hours\n");
63      }
64   }
65   return 0;
66}
67
68

yzhw 2011-01-09 20:22 发表评论

PKU1240 Pre-Post-erous! 基于树的遍历概念的题目

yzhw — Sat, 08 Jan 2011 10:50:00 GMT

题意：
给出一棵K叉树的前序和后序遍历，问中序遍历有多少种

解法：
之所以中序遍历会有多种，原因是存在不满儿子的节点，导致树的形态有不同
通过前序和后序遍历，可以将每一棵子树划分出来，然后递归的累乘计算个数（乘法原理），最后再乘以C_kⁿ，n为当前节点的子树个数

代码：

1# include <cstdio>
2using namespace std;
3# include <cstdlib>
4# include <cstring>
5char pre[50],post[50];
6int c[21][21],k;
7int solve(int s1,int s2,int l)
8{
9    int ans=1,co=0,last;
10    for(int i=s1+1;i<s1+l;i+=s2-last)
11    {
12       last=s2;
13       co++;
14       for(;post[s2]!=pre[i];s2++);
15       ans*=solve(i,last,++s2-last);
16    }
17    return ans*c[k][co];
18}
19int main()
20{
21    memset(c,0,sizeof(c));
22    for(int i=0;i<=20;i++) c[i][0]=c[i][i]=1;
23    for(int i=1;i<=20;i++)
24      for(int j=1;j<i;j++)
25        c[i][j]=c[i-1][j-1]+c[i-1][j];
26    while(scanf("%d%s%s",&k,pre,post)==3)
27       printf("%d\n",solve(0,0,strlen(pre)));
28    return 0;
29}
30

yzhw 2011-01-08 18:50 发表评论

pku 3306 Busy Airport 模拟+堆

yzhw — Wed, 05 Jan 2011 19:22:00 GMT

摘要: 题意就不说了，就是模拟一个机场的起降时间如果当前时刻不能起飞，则推迟10分钟再次尝试这题里面还包含一个历法子问题，甚是麻烦。。于是就用了各种C++面向对象技术把条理理清楚历法的详细解释在题目最底端，不是我们用的公历直接贴代码了 Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighli... 阅读全文

yzhw 2011-01-06 03:22 发表评论

pku2525 Text Formalization 恶心的模拟

yzhw — Tue, 04 Jan 2011 15:36:00 GMT

摘要: 题意是这样：将一篇文章中的缩写和简略语替换成原来的样子。有点要求，缩写只在第一次替换。如果有多种替换方法，则最先出现的可替换词优先替换。如果还有重复，则列表前面的先替换。解法：狂用string.h里的函数然后+暴力就可以了，这种模拟题一般不会考到什么算法。。代码： Code highlighting produced by Actipro CodeHighlighter (freeware)ht... 阅读全文

yzhw 2011-01-04 23:36 发表评论

pku 1262 input 离散化

yzhw — Fri, 10 Dec 2010 08:52:00 GMT

题意：
给出一些瓷砖，以及需要铺的面积w*h（从(0,0)到(w,h)），求：
（1）这些瓷砖是否有重叠
（2）这些瓷砖是否超过了地面的边界
（3）这些瓷砖能否完整的铺盖地面
瓷砖个数n<100
解法：
对于第一问，传统的做法应该是离散化+线段树。但是此题数据量很小，n<100离散化后面积不过160000，可以暴力判重。
对于第二问，扫描一遍即可
对于第三问，计算下总面积即可。
代码：

1 # include <cstdio>
2 using namespace std;
3 # include <vector>
4 # include <algorithm>
5 # include <cstring>
6 int data[101][4],c1,tmp1[500],c2,tmp2[500],n,w,h;
7 bool used[500][500];
8 int main()
9 {
10     int test;
11     scanf("%d",&test);
12     while(test--)
13     {
14         int total=0;
15         scanf("%d%d%d",&w,&h,&n);
16         c1=c2=0;
17         memset(used,0,sizeof(used));
18         for(int i=0;i<n;i++)
19         {
20             scanf("%d%d%d%d",&data[i][0],&data[i][1],&data[i][2],&data[i][3]);
21             tmp1[c1++]=data[i][0];
22             tmp1[c1++]=data[i][2]-1;
23             tmp2[c2++]=data[i][1];
24             tmp2[c2++]=data[i][3]-1;
25         }
26         sort(tmp1,tmp1+c1);
27         c1=unique(tmp1,tmp1+c1)-tmp1;
28         sort(tmp2,tmp2+c2);
29         c2=unique(tmp2,tmp2+c2)-tmp2;
30         for(int i=0;i<n;i++)
31         {
32             int xl=lower_bound(tmp1,tmp1+c1,data[i][0])-tmp1,xh=lower_bound(tmp1,tmp1+c1,data[i][2]-1)-tmp1;
33             int yl=lower_bound(tmp2,tmp2+c2,data[i][1])-tmp2,yh=lower_bound(tmp2,tmp2+c2,data[i][3]-1)-tmp2;
34             for(int j=xl;j<=xh;j++)
35                 for(int k=yl;k<=yh;k++)
36                     if(used[j][k])
37                     {
38                         printf("NONDISJOINT\n");
39                         goto end;
40                     }
41                     else used[j][k]=true;
42         }
43         for(int i=0;i<n;i++)
44             if(data[i][0]<0||data[i][0]>w||data[i][2]<0||data[i][2]>w||data[i][1]<0||data[i][1]>h||data[i][3]<0||data[i][3]>h)
45             {
46                 printf("NONCONTAINED\n");
47                 goto end;
48             }
49         for(int i=0;i<n;i++)
50             total+=(data[i][2]-data[i][0])*(data[i][3]-data[i][1]);
51         if(total!=w*h) printf("NONCOVERING\n");
52         else printf("OK\n");
53         end:;
54     }
55 }
56

yzhw 2010-12-10 16:52 发表评论

fzu 2007 Selecting courses （The 35th ACM/ICPC Asia Regional Fuzhou Site）贪心+堆

yzhw — Mon, 06 Dec 2010 16:09:00 GMT

题意：
给出一堆课，选课时间从s_i到e_i，每个学生可以从任意一个时刻开始选课，然后每隔5分钟选一次，如果在某个时刻t，存在某个课程i,s_ii>t，那么可以选这门课。问最多可以选多少门课。
解法：
首先注意，选课时间是开区间，（s,e），需要事先处理为[s*2+1,e*2-1]
然后就可以枚举起点然后贪心，每次取覆盖当前时间点的右端点最小的那个区间（课程）来选。
具体实现方法可以先按照s排序，然后建立一个以e为关键字的小根堆，动态统计，这样复杂度O(nlogn)
代码:

1 # include <cstdio>
2 # include <queue>
3 # include <algorithm>
4 # include <vector>
5 using namespace std;
6 int n;
7 const int N=305;
8 struct node
9 {
10    int s,e;
11 }data[N];
12 bool cmp(const node &a,const node &b)
13 {
14    return a.s<b.s;
15 }
16 struct cmp1
17 {
18    bool operator()(const node &a,const node &b) const
19    {
20         return a.e>b.e;
21    }
22 };
23 int main()
24 {
25     while(true)
26     {
27        scanf("%d",&n);
28        if(!n) break;
29        int start=0xfffffff,end=-1;
30        for(int i=0;i<n;i++)
31        {
32          scanf("%d%d",&data[i].s,&data[i].e);
33          data[i].s=data[i].s*2+1;
34          data[i].e=data[i].e*2-1;
35          start=min(start,data[i].s);
36          end=max(data[i].e,end);
37        }
38        sort(data,data+n,cmp);
39        int res=0;
40        for(int s=start;s<=start+10;s++)
41        {
42           int total=0,p=0;
43           priority_queue<node,vector<node>,cmp1> q;
44           for(int t=s;t<=end;t+=10)
45           {
46              while(p<n&&data[p].s<=t)
47                q.push(data[p++]);
48              while(!q.empty()&&q.top().e<t) q.pop();
49              if(!q.empty())
50              {
51                total++;
52                q.pop();
53              }
54           }
55           res=max(res,total);
56        }
57        printf("%d\n",res);
58     }
59     return 0;
60 }
61

yzhw 2010-12-07 00:09 发表评论

pku 3668 Game of Lines hash

yzhw — Sat, 04 Dec 2010 17:26:00 GMT

题意：
给出一些点，求出由这些点可以构成多少斜率不同的线段。
解法：
O（N²）枚举直线，然后hash记录斜率（要特别考虑斜率不存在的情况），注意浮点数的比较精度控制在1e-8或者用pair来通分比较。。
代码：

1# include <iostream>
2# include <cmath>
3using namespace std;
4# include <set>
5struct cmp
6{
7   bool operator()(const double a,const double b) const
8   {
9      return fabs(a-b)>1e-8&&a<b;
10   }
11};
12set<double,cmp> refer;
13bool sp=0;
14int data[201][2];
15int main()
16{
17   int n;
18   cin>>n;
19   for(int i=0;i<n;i++)
20   {
21     cin>>data[i][0]>>data[i][1];
22     for(int j=0;j<i;j++)
23       if(data[j][0]==data[i][0])
24         sp=1;
25       else
26          refer.insert((data[j][1]-data[i][1])/(double)(data[j][0]-data[i][0]));
27   }
28   cout<<refer.size()+sp<<endl;
29  // system("pause");
30   return 0;
31}
32

yzhw 2010-12-05 01:26 发表评论

pku 3497 Assemble 二分+模拟+STL

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

题意：
若干电脑配件，若干型号，每个型号都有价格和性能指数。求在K钱内的配置方案，使得最差性能最好。。
解法：
二分+判断
代码：

1# include <cstdio>
2# include <string>
3# include <cstring>
4# include <map>
5# include <set>
6# include <algorithm>
7# include <vector>
8using namespace std;
9struct node
10{
11   string name;
12   int p,q;
13   node(string na,int pr,int qu):name(na),p(pr),q(qu) {};
14};
15struct cmp
16{
17   bool operator()(const node &a,const node &b) const
18   {
19        return a.name<b.name;
20   }
21};
22int n,m;
23map<string,vector<node> >data;
24vector<int> refer;
25bool chk(int mid)
26{
27   long long total=0;
28   for(map<string,vector<node> >::iterator i=data.begin();i!=data.end();i++)
29   {
30      int tp=0xfffffff;
31      for(vector<node>::iterator j=(i->second).begin();j!=(i->second).end();j++)
32        if(j->q>=mid&&j->p<tp)
33           tp=j->p;
34      total+=tp;
35   }
36   return total<=(long long)m;
37}
38int main()
39{
40    int test;
41    scanf("%d",&test);
42    while(test--)
43    {
44       scanf("%d%d",&n,&m);
45       data.clear();
46       refer.clear();
47       for(int i=0;i<n;i++)
48       {
49          char type[128],name[128];
50          int p,q;
51          scanf("%s%s%d%d",type,name,&p,&q);
52          data[string(type)].push_back(node(string(name),p,q));
53          refer.push_back(q);
54       }
55       sort(refer.begin(),refer.end());
56       vector<int>::iterator end=unique(refer.begin(),refer.end());
57       while(refer.end()!=end) refer.pop_back();
58       int s=0,e=refer.size()-1;
59       while(s<=e)
60       {
61          int mid=(s+e)>>1;
62          if(chk(refer[mid])) s=mid+1;
63          else e=mid-1;
64       }
65       printf("%d\n",refer[s-1]);
66    }
67    return 0;
68}
69
70

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

pku 1209 Calendar 历法问题，超多trick

yzhw — Fri, 26 Nov 2010 12:38:00 GMT

简要题意：
给出1900-1999 年中任一一年的事件，(d.m.p)，分别表示日、月、重要度（提前p天需要通知）。然后给出n个时间点，要求输出需要提醒的日期。排序规则很诡异（与官方测试数据不同），引poj的discuss：先是按时间排，时间相同就看是不是今天，是今天就只管输入顺序，不是今天就先考虑星星的问题再来输入顺序。

我的解法：
将事件看做区间，开一个366的二维数组或者vector，来记录覆盖每个时间点的事件。然后对每个数组按照上述排序规则进行排序。
输出的时候有点诡异，所有的时间输出采取右对齐并占3字节。
还有个更诡异的，时期会套圈。。。（感觉和题意描述有点区别），就是说，如果输出12.31号需要提醒的事件，那么需要考虑1月份的，然后排序的时候1月份还要排在后面。。。。

代码：

  1 Source Code
  2 Problem: 1209        User: yzhw
  3 Memory: 616K        Time: 0MS
  4 Language: G++        Result: Accepted
  5
  6     * Source Code
  7
  8       # include <cstdio>
  9       # include <vector>
10       # include <cstring>
11       # include <string>
12       # include <algorithm>
13       using namespace std;
14       struct node
15       {
16           int t,r,id,d,m;
17           char name[255];
18           bool operator<(const node &pos) const
19           {
20               if(t!=pos.t) return t<pos.t;
21               else if(r!=pos.r) return r>pos.r;
22               else return id<pos.id;
23           }
24       };
25       vector<node> day[400];
26
27       int main() {
28       //    freopen("c.in","r",stdin);
29       //    freopen("ans.txt","w",stdout);
30           int year,c=0;
31           scanf("%d",&year);
32           int time[13];
33           time[0]=0;
34           for(int i=1;i<=12;i++)
35               if(i<=7&&i%2||i>7&&!(i%2))
36                   time[i]=31;
37               else
38                   time[i]=30;
39           if(year%4==0)
40               time[2]=29;
41           else
42               time[2]=28;
43           for(int i=2;i<=12;i++)
44               time[i]+=time[i-1];
45           bool flag=false;
46           while(true)
47           {
48               char jud[5];
49               scanf("%s",jud);
50               if(jud[0]=='#') break;
51               else if(jud[0]=='A')
52               {
53                   int d,m,l;
54                   scanf("%d%d%d",&d,&m,&l);
55                   char str[300];
56                   gets(str);
57                   while(str[0]==' ')
58                       for(int i=0;i<strlen(str);i++)
59                           str[i]=str[i+1];
60                   for(int i=max(1,time[m-1]+d-l);i<=time[m-1]+d;i++)
61                   {
62                       node tmp;
63                       strcpy(tmp.name,str);
64                       tmp.id=c;
65                       tmp.d=d;
66                       tmp.m=m;
67                       if(i!=time[m-1]+d)
68                          tmp.r=l-(time[m-1]+d-i-1);
69                       else
70                          tmp.r=8;
71                       tmp.t=time[m-1]+d;
72                       day[i].push_back(tmp);
73                   }
74
75                   for(int i=time[12]+time[m-1]+d-l;i<=time[12];i++)
76                   {
77                       node tmp;
78                       strcpy(tmp.name,str);
79                       tmp.id=c;
80                       tmp.d=d;
81                       tmp.m=m;
82                       tmp.r=l-(time[m-1]+d-1+time[12]-i+1-1);
83                       tmp.t=time[m-1]+d+time[12];
84                       day[i].push_back(tmp);
85                   }
86                   c++;
87               }
88               else
89               {
90                   if(!flag)
91                   {
92                       flag=true;
93                       for(int i=0;i<=time[12];i++)
94                           sort(day[i].begin(),day[i].end());
95                   }
96                   int d,m;
97                   scanf("%d%d",&d,&m);
98                   printf("Today is:%3d%3d\n",d,m);
99                   for(int i=0;i<day[time[m-1]+d].size();i++)
100                   {
101                      printf("%3d%3d ",day[time[m-1]+d][i].d,day[time[m-1]+d][i].m);
102                      if(day[time[m-1]+d][i].t==time[m-1]+d) printf("*TODAY*");
103                      else
104                      {
105                        for(int j=0;j<day[time[m-1]+d][i].r;j++)
106                            printf("*");
107                        for(int j=day[time[m-1]+d][i].r+1;j<8;j++)
108                            printf(" ");
109                      }
110                      printf(" %s\n",day[time[m-1]+d][i].name);
111                   }
112                   printf("\n");
113               }
114           }
115           return 0;
116       }
117
118

yzhw 2010-11-26 20:38 发表评论

pku 2823 Sliding Window 赤裸裸的单调队列，G++还TLE，C++5S不到。。orz

yzhw — Mon, 08 Nov 2010 15:54:00 GMT

不解释了，求固定长度的区间最大值和最小值，单调队列即可。。

1 # include <cstdio>
2 //# include
3 using namespace std;
4 const int N=1000005;
5 int data[N],q[N],s=-1,e=-1;
6 int main()
7 {
8     int n,k;
9     scanf("%d%d",&n,&k);
10     for(int i=0;i<n;i++)
11       scanf("%d",data+i);
12     for(int i=0;i<n;i++)
13     {
14        while(s!=e&&i-q[s+1]>=k) s++;
15        while(s!=e&&data[q[e]]>=data[i]) e--;
16        q[++e]=i;
17        if(i>=k-1) printf("%d%c",data[q[s+1]],i!=n-1?' ':'\n');
18     }
19     s=e=-1;
20     for(int i=0;i<n;i++)
21     {
22        while(s!=e&&i-q[s+1]>=k) s++;
23        while(s!=e&&data[q[e]]<=data[i]) e--;
24        q[++e]=i;
25        if(i>=k-1) printf("%d%c",data[q[s+1]],i!=n-1?' ':'\n');
26     }
27    // system("pause");
28     return 0;
29
30 }
31

yzhw 2010-11-08 23:54 发表评论

pku 1706 References 简单hash

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

题意很简单，把文章中的引用信息整理到最后并给它们重新编号。。我想不懂为什么我自己写hash效率那么低。。。还有就是看清题目，空行是仅仅包括空格、TAB、回车的行

  1 # include <stdio.h>
  2 # include <stdlib.h>
  3 # include <string.h>
  4 //char tmp[100];
  5 struct part
  6 {
  7     char tmp[3][100];
  8     int c;
  9     int id;
10 }refer[40001];
11 int c=0,hashc=1;
12 int hash_map[100001][2];
13 void puthash(int num,int val)
14 {
15     int h=num%99997;
16     while(hash_map[h][0]!=-1&&hash_map[h][0]!=num)
17          h=(h+1)%100000;
18     if(hash_map[h][0]==-1)
19     {
20         hash_map[h][0]=num;
21         hash_map[h][1]=val;
22
23     }
24 }
25 int gethash(int num)
26 {
27     int h=num%99997;
28     while(hash_map[h][0]!=-1&&hash_map[h][0]!=num)
29              h=(h+1)%100000;
30     if(hash_map[h][0]==-1)
31         return -1;
32     else
33         return hash_map[h][1];
34 }
35 int cmp(const void *a,const void *b)
36 {
37     struct part *aa=(struct part *)a;
38     struct part *bb=(struct part *)b;
39     return aa->id-bb->id;
40 }
41 int emptyline(char *str)
42 {
43     int i;
44     if(strlen(str)==0) return 1;
45     for(i=0;i<strlen(str);i++)
46       if(str[i]!=' '&&str[i]!='\t')
47         return 0;
48     return 1;
49 }
50 int main()
51 {
52 //    freopen("input.txt","r",stdin);
53 //    freopen("ans.txt","w",stdout);
54     int i,j;
55         char str[100];
56     int jud=0;
57     memset(hash_map,-1,sizeof(hash_map));
58
59     while(gets(str))
60     {
61         //if(!strcmp(str,"---")) break;
62         if(str[0]=='[')
63         {
64             for(i=0;str[i]!=']';i++);
65             str[i]='\0';
66             refer[c].id=atoi(str+1);
67             refer[c].c=0;
68             strcpy(refer[c].tmp[refer[c].c++],str+i+1);
69             while(gets(str))
70             {
71                 if(emptyline(str)) break;
72
73                 else
74                 {
75                     strcpy(refer[c].tmp[refer[c].c++],str);
76                 }
77             }
78             c++;
79         }
80         else if(emptyline(str)) continue;
81         else
82         {
83             if(jud==0)
84                 jud=1;
85             else
86                 printf("\n");
87             do
88             {
89                 if(emptyline(str)) break;
90
91                 for(i=0;i<strlen(str);i++)
92                 {
93                     if(str[i]!='[')
94                         printf("%c",str[i]);
95                     else
96                     {
97                         int num,h;
98                         for(j=i;str[j]!=']';j++);
99                         str[j]='\0';
100                         num=atoi(str+i+1);
101                         str[j]=']';
102                         h=gethash(num);
103                         if(h==-1)
104                         {
105                             puthash(num,hashc);
106                             h=hashc++;
107                         }
108                         printf("[%d]",h);
109                         i=j;
110                     }
111                 }
112                 printf("\n");
113
114             }while(gets(str));
115         }
116     }
117     for(i=0;i<c;i++)
118     {
119         int res=gethash(refer[i].id);
120         if(res==-1)
121         {
122             puthash(refer[i].id,hashc);
123             res=hashc++;
124         }
125         refer[i].id=res;
126     }
127     qsort(refer,c,sizeof(struct part),cmp);
128
129     for(i=0;i<c;i++)
130     {
131         printf("\n");
132         printf("[%d]",refer[i].id);
133         for(j=0;j<refer[i].c;j++)
134             printf("%s\n",refer[i].tmp[j]);
135     }
136 printf("\n");
137     return 0;
138 }
139

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