永夜初晗

  • 主页
  • 文章列表
  • 三国闯关杀
所有文章 友链 关于我

永夜初晗

  • 主页
  • 文章列表
  • 三国闯关杀

hdu4308 Saving Princess claire 搜索解题报告(多校1)

9月 16

题目大意就是从Y走到C经过*最少是多少,其中#不可走,P可传送至任何一个为P的地方,这题可以广搜,hdu给出的是最短路,下面是官方的解题报告

给出的地图中,Y为起点,C为终点,#点不能通过,可直接忽略。所有的P为互通的传送门,故可将所以的P看作同一个点。每个能通过的点可以向上下左右四个方向走,如果对应的方向可以通过,则连边,若要走到的点是*,则边权为通过的费用,否则边权为0。
连边后求Y到C的最短路即可。

我的代码

hdu4308 Saving Princess claireview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <algorithm>
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
using namespace std;

#define zero(a) memset(a,0,sizeof(a))
#define one(a) memset(a,1,sizeof(a))
#define fone(a) memset(a,-1,sizeof(a))
#define pow2(a) ((a)*(a))
#define pow3(a) ((pow2(a))*(a))

char mat[5005][5005];
bool hash[5005];

int fx[][2]={
{-1,0},
{0,-1},
{1,0},
{0,1}
};

struct loc{
int x,y;
}p[505],start,end;

struct prog{
int x,y;
int cnt;
};

bool operator<(prog a,prog b)
{
return a.cnt>b.cnt;
}

int p_num;

int main()
{
int r,c,cost;
while(~scanf("%d%d%d",&r,&c,&cost))
{
priority_queue<prog>que;
int i,j;
p_num=0;
for(i=0;i<r;i++)
{
scanf("%s",mat[i]);
for(j=0;j<c;j++)
{
if(mat[i][j]=='P')
p[p_num].x=i,p[p_num++].y=j;
if(mat[i][j]=='Y')
start.x=i,start.y=j;
if(mat[i][j]=='C')
end.x=i,end.y=j;
}
}
prog a;
a.cnt=0;
a.x=start.x;
a.y=start.y;
que.push(a);
zero(hash);
hash[a.x*c+a.y]=1;
while(!que.empty())
{
prog tmp=que.top();
que.pop();
for(i=0;i<4;i++)
{
a=tmp;
a.x+=fx[i][0];
a.y+=fx[i][1];

if(a.x<0||a.y<0||a.x>=r||a.y>=c)
continue;
if(mat[a.x][a.y]=='#')
continue;
if(hash[a.x*c+a.y]==1)
continue;
hash[a.x*c+a.y]=1;

if(mat[a.x][a.y]=='C')
{
printf("%d\n",cost*a.cnt);
goto over;
}
if(mat[a.x][a.y]=='*')
a.cnt++;
if(mat[a.x][a.y]=='P')
{
for(j=0;j<p_num;j++)
{
prog t;
t.x=p[j].x;
t.y=p[j].y;
hash[t.x*c+t.y]=1;
t.cnt=a.cnt;
que.push(t);
}
continue;
}
que.push(a);
}
}
printf("Damn teoy!\n");
over:;
}
return 0;
}

  • hdu
  • 广度优先搜索
  • 最短路
  • 算法竞赛

展开全文 >>

hdu4412 Sky Soldiers 动态规划 杭州网赛的第三题

9月 16

题目大意是有k个伞兵落到地面上,已知每个人落点的概率,有m个物资站,落地后要去最近的站。问如何安排这些物资站,使得伞兵落地后行走的期望距离的和最小。(所有落点最多1000个)。

显然是个dp题,我们可以先预处理下,对每个落点点求出他的概率总和,代表伞兵落在这点的权。可以直到物资站一定悬在伞兵落下的那些点上,所以我们就可以用dpij 表示前i个落地点中选择j个作为物资点,则很容易想到转移方程dpij=min(dpkj1+diski),其中j1=j+1, diski表示在[k,i]区间的落地点选则一个作为物资点所走距离最小值的期望(就是每点到物资点的距离乘该点概率的总和)。

现在关键就是求dis,其实我们注意到 假设对于[i,j],假设选取k作为物资点,则有

disij=∑kn=i(ak−an)pn+∑jn=k+1(an−ak)pn

而若选择k+1作为物资点,则有

dis‘ij=∑kn=i(ak+1−an)pn+∑jn=k+1(an−ak+1)pn

则相减并化简得

dis‘ij−disij=(ak1−ak)(∑kn=ipn−∑jn=k+1pn)=(ak1−ak)(sumik−sumk1j)

设tmp=dis‘ij−disij,sum可以很容易求出,这样很显然,当k增加时,tmp的值也在增加,所以,若选取k作为物资点,则要tmp≥0,否则我们可以选取k+1作为物资点,这样,可以对dis进行预处理,然后就可以得出答案

hdu4412 Sky Soldiersview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <algorithm>
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <map>
using namespace std;

#define zero(a) memset(a,0,sizeof(a))
#define one(a) memset(a,1,sizeof(a))
#define fone(a) memset(a,-1,sizeof(a))
#define pow2(a) ((a)*(a))
#define pow3(a) ((pow2(a))*(a))

struct prog{
double p;
int k;
}pos[1005];
bool cmp(prog a,prog b)
{
return a.k<b.k;
}
double dis[1005][1005];
double sum[1005][1005];
double dp[1005][1005];
int main()
{
int kx,m;
while(scanf("%d%d",&kx,&m),kx||m)
{
int i,j,k;
int pos_num=0;
map<int,int>mp;

for(i=0;i<kx;i++)
{
int n;
scanf("%d",&n);
//cout<<1<<endl;
for(j=0;j<n;j++)
{
int t;
double p;
scanf("%d%lf",&t,&p);
if(mp.count(t)==0)
{
mp[t]=pos_num;
pos[pos_num].p=p;
pos[pos_num++].k=t;
}
else
{
pos[mp[t]].p+=p;
}
}
}

sort(pos,pos+pos_num,cmp);

zero(sum);
for(i=0;i<pos_num;i++)
{
sum[i][i]=pos[i].p;
for(j=i+1;j<pos_num;j++)
{
sum[i][j]=sum[i][j-1]+pos[j].p;
}
}

zero(dis);
for(i=0;i<pos_num;i++)
{
for(j=i+1;j<pos_num;j++)
{
dis[i][j]=0.0;
for(k=i+1;k<=j;k++)
{
dis[i][j]+=(pos[k].k-pos[i].k)*pos[k].p;
}

double tmp=dis[i][j];
for(k=i+1;k<=j;k++)
{
tmp=(pos[k].k-pos[k-1].k)*(sum[i][k-1]-sum[k][j])+dis[i][j];
if(tmp<dis[i][j])
dis[i][j]=tmp;
else
break;
}
//cout<<dis[i][j]<<endl;
}
}

for(i=0;i<pos_num;i++)
{
//dp[i][0]=0;
dp[i][1]=dis[0][i];
for(j=2;j<=m;j++)
{
dp[i][j]=1000000000.0;
for(k=0;k<=i;k++)
{
dp[i][j]=min(dp[i][j],dp[k][j-1]+dis[k+1][i]);
}
}
}

printf("%.2lf\n",dp[pos_num-1][m]);
}
return 0;
}
  • 动态规划
  • hdu
  • 算法竞赛

展开全文 >>

hdu4419 Colourful Rectangle 搜索+矩形分割 杭州赛区网赛最后一题

9月 16

这题就是一个矩阵分割,因为之前做过USACO上类似的一题,所以最开始就看了这题

矩阵分割,有多种情况,具体可以参考我的USACO 3.1.4 Shaping Regions 搜索+矩形切割

但这题略有不同,USACO上面是颜色覆盖,这里是颜色相加,所以对于相交的区域不能那个直接计算面积,还要继续递推直到最后一个矩形

但有一个问题,矩形太多,递推超时,注意到颜色只有三种,所以我们可以对颜色进行一次一次排序(让R,G,B顺序),如果到分割第t个矩形时,当前所加的颜色含有第t个矩形的颜色,则我们可以直接跳转到下一个颜色区域,这样就可以避免重复搜索

还有一个问题,就是颜色的处理,因为颜色的相加,可以用位运算来解决,R-1,G-2,B-4,这样就对颜色的相加转化成或运算,具体可看我的代码(刚用我的代码提交了下,发现不论时间还是空间排行暂时第一,第一次啊!)

hdu4419 Colourful Rectangleview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

#define zero(a) memset(a,0,sizeof(a))
#define one(a) memset(a,1,sizeof(a))
#define fone(a) memset(a,-1,sizeof(a))
#define pow2(a) ((a)*(a))
#define pow3(a) ((pow2(a))*(a))

__int64 ans[10];
struct rect{
int llx,lly,urx,ury,c;
}cfx[10005];
const int sx[]={1,2,4,3,5,6,7};
int color[5];
int color_rank[3];
void DFS(int lx,int ly,int rx,int ry,int t,int c)
{
if(lx==rx||ly==ry)
return ;
if(t==-1)
{
if(c!=0)
ans[c]+=((__int64)(rx-lx))*(ry-ly);
return ;
}
if(t>=0&&t<color_rank[0]&&((c|1)==c))
{
DFS(lx,ly,rx,ry,-1,c);
return ;
}
else if(t>=color_rank[0]&&t<color_rank[1]&&((c|2)==c))
{
DFS(lx,ly,rx,ry,color_rank[0]-1,c);
return ;
}
else if(t>=color_rank[1]&&t<color_rank[2]&&((c|4)==c))
{

DFS(lx,ly,rx,ry,color_rank[1]-1,c);
return ;
}

if(cfx[t].llx>=rx||cfx[t].lly>=ry||cfx[t].urx<=lx||cfx[t].ury<=ly)
{
DFS(lx,ly,rx,ry,t-1,c);
}
else
{
int k1,k2,k3,k4;
k1=max(lx,cfx[t].llx);
k2=min(rx,cfx[t].urx);
if(lx<k1)
DFS(lx,ly,k1,ry,t-1,c);
if(rx>k2)
DFS(k2,ly,rx,ry,t-1,c);

k3=max(ly,cfx[t].lly);
k4=min(ry,cfx[t].ury);
if(ly<k3)
DFS(k1,ly,k2,k3,t-1,c);
if(ry>k4)
DFS(k1,k4,k2,ry,t-1,c);
if(k1!=k2&&k3!=k4)
DFS(min(k1,k2),min(k3,k4),max(k1,k2),max(k3,k4),t-1,cfx[t].c|c);
}
}
bool cmp(rect a,rect b)
{
return a.c<b.c;
}

int main()
{
int T,cnt=1;
scanf("%d",&T);
while(T--)
{
int x,y,n,i;
scanf("%d",&n);
x=y=0;
zero(ans);
zero(color);
for(i=0;i<n;i++)
{
char str[3];
scanf("%s",str);
if(str[0]=='R')
cfx[i].c=1;
else if(str[0]=='G')
cfx[i].c=2;
else if(str[0]=='B')
cfx[i].c=4;

scanf("%d%d%d%d",&cfx[i].llx,&cfx[i].lly,&cfx[i].urx,&cfx[i].ury);
x=max(x,cfx[i].urx);
y=max(y,cfx[i].ury);
color[cfx[i].c]++;
}
sort(cfx,cfx+n,cmp);
color_rank[0]=color[1];
color_rank[1]=color_rank[0]+color[2];
color_rank[2]=color_rank[1]+color[4];

DFS(0,0,x,y,n-1,0);

printf("Case %d:\n",cnt++);
for(i=0;i<7;i++)
printf("%I64d\n",ans[sx[i]]);
}
return 0;
}
  • 深度优先搜索
  • hdu
  • 矩形
  • 分治
  • 算法竞赛

展开全文 >>

hdu4602 Partition 2013多校第一场100

9月 16

可以知道对于任何数n都可以写成n=x+[y+z+…],则对于任意的一个x(0≤x<n),后面的式子有2n−x−1种写法

假设对于给定的k,题目要求的就是f+n

则对于x有两种可能
若x=k,则这2n−x−1个式子中,因为第一项就是k,所以每一个式子至少含有1个k,现在就看其余项中含有多少k,而其余项就是求f(n−x)
若x≠k相等,则第一项不含有k,就看其余项中含有含有多少k,依旧是求f(n−x)
注意到,当k>n是,f(n)=0

则可以得到
fn=∑n−1i=kfi+2n−k−1

于是可以求出通项公式
fn=(n−k+3)∗2n−k−2(n>k)

官方解题报告
我们特判出n≤k的情况。
对于1≤k<n,我们可以等效为n个点排成一列,并取出其中的连续k个点。下面分两种情况考虑:

第一种情况,被选出的不包含断电,那么有n−k−1种情况完成上述操作,剩下未被圈的点之间还有n−k−2个位置,可以在每个位置断开,所以共 (n−k−1)∗2n−k−2 种方法。

第二种情况,即被选出的包含端点,那么有两种情况,并且剩余共n−k−1个位置,所以共2∗2n−k−1种方法。

总计2×2n−k−1+(n−k−1)2n−k−2=(n−k−3)2n−k−1。

more >>
  • 递归
  • 数论
  • hdu
  • 算法竞赛

展开全文 >>

hdu4611 Balls Rearrangement 最大公约数 2013多校2-1001

9月 16

题目实际上就是求n−1∑i=0|imoda−imodb|

既然有取余,明显会有循环节,很显然循环节是lcm(a,b)

那就求出循环节部分的值再乘以循环的次数再加上其余部分就可以了

多校的时候a,b都取的int,WA了 后来才弄对

hdu4611 Balls Rearrangementview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include <algorithm>
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;

#define zero(a) memset(a,0,sizeof(a))
#define one(a) memset(a,1,sizeof(a))
#define fone(a) memset(a,-1,sizeof(a))
#define pow2(a) ((a)*(a))
#define pow3(a) ((pow2(a))*(a))

__int64 gcd(__int64 a,__int64 b)
{
return b==0?a:gcd(b,a%b);
}
__int64 lcm(__int64 a,__int64 b)
{
return a/gcd(a,b)*b;
}

__int64 abs(__int64 k)
{
return k<0?-k:k;
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
__int64 n,a,b;
scanf("%I64d%I64d%I64d",&n,&a,&b);

if(a>b)
{
__int64 t;
t=b;
b=a;
a=t;
}

__int64 k=gcd(a,b);
__int64 ga=a/k;
__int64 gb=b/k;
__int64 i,j;
__int64 sum=0;
__int64 sumi;
__int64 sumn=0;
__int64 x=0;
__int64 nm=(n%lcm(a,b))/b;
__int64 tx=0;
for(i=0;i<ga;i++)
{
sumi=0;
__int64 anum=x/a;
__int64 x1=(anum+1)*a-x;
sumi+=x1*abs(x%a-x%b);
x+=x1;
__int64 sy=b-x1;
while(sy>=a)
{
sy-=a;
sumi+=a*abs(x%a-x%b);
x+=a;
}
sumi+=sy*abs(x%a-x%b);

x+=sy;

sum+=sumi;
}
x=0;
for(i=0;i<nm;i++)
{
sumi=0;
__int64 anum=x/a;
__int64 x1=(anum+1)*a-x;
sumi+=x1*abs(x%a-x%b);
x+=x1;
__int64 sy=b-x1;
while(sy>=a)
{
sy-=a;
sumi+=a*abs(x%a-x%b);
x+=a;
}
sumi+=sy*abs(x%a-x%b);

x+=sy;

sumn+=sumi;
}

__int64 ans=sum*(n/lcm(a,b))+sumn;

__int64 nab=n%lcm(a,b);
for(i=nm*b;i<nab;i++)
ans+=abs(i%a-i%b);

printf("%I64d\n",ans);

}
return 0;
}
  • 最大公约数
  • 数论
  • hdu
  • 算法竞赛

展开全文 >>

hdu4619 Warm up 2 二分图匹配 2013多校第二场1009

9月 16

实际上就是求的二分图最大匹配

hdu4619 Warm up 2view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;

#define zero(a) memset(a,0,sizeof(a))
#define one(a) memset(a,1,sizeof(a))
#define fone(a) memset(a,-1,sizeof(a))
#define pow2(a) ((a)*(a))
#define pow3(a) ((pow2(a))*(a))

struct prog{
int x;int y;
}h[1010],s[1010];
bool map[1010][1010];
int link[1010];
bool vis[1010];
int n,m;
bool check(int i,int j)
{
if(h[i].x==s[j].x&&h[i].y==s[j].y)
return 1;
if(h[i].x+1==s[j].x&&h[i].y==s[j].y)
return 1;
if(h[i].x==s[j].x&&h[i].y==s[j].y+1)
return 1;
if(h[i].x+1==s[j].x&&h[i].y==s[j].y+1)
return 1;
return 0;
}

bool find ( int k )
{//对k寻找匹配,如果找到就记录匹配,并返回true,否则返回false
int i , j ;
for ( i = 1 ; i <= m ; i ++ )
{//对所有节点遍历一遍,寻找没有访问过并且与i连同的点
if ( map [k][i] ==true && ! vis[i] )
{
vis [i] = true ; //记录改点以被访问
if ( link [i] == 0 || find ( link [i] ) )
{//如果该点还未与其他点匹配,或还能找到其他点能与该点匹配的点j进行匹配,即存在增广路
link [ i ] = k ; //将i与k进行匹配
return true;
}
}
}
return false;
}

int main()
{

while(~scanf("%d%d",&n,&m),n||m)
{
int i,j;
for(i=1;i<=n;i++)
scanf("%d%d",&h[i].x,&h[i].y);
for(i=1;i<=m;i++)
scanf("%d%d",&s[i].x,&s[i].y);

zero(map);
zero(link);
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
map[i][j]=check(i,j);
// if(map[i][j]==1)
// cout<<i<<' '<<j<<endl;
}
}

int ans = 0 ; //最大匹配数
for ( i = 1 ; i <= n ; i ++ )
{
memset ( vis , false , sizeof ( vis ) ) ;//对所有数据都初始为0,表明数据还没有试探
if ( find ( i ) ) //如果对i找到一个匹配
ans ++ ;
}
// cout<<ans<<endl;
printf("%d\n",m+n-ans);
}
return 0;
}

  • 贪心
  • hdu
  • 二分图
  • 图论
  • 最大匹配
  • 算法竞赛

展开全文 >>

hdu4632 Palindrome subsequence 20103多校4-1001

9月 16

dp题

hdu4632 Palindrome subsequenceview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <algorithm>
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;

const int maxn=1000+10;
const int mod=10007;
int dp[maxn][maxn];
char s[maxn];
int len;
int main()
{
int T,cas=1;
scanf("%d",&T);
while(T--)
{
scanf("%s",s);
len=strlen(s);
int i,j,k;
for(i=len-1;i>=0;i--)
{
for(k=0;i+k<len;k++)
{
j=i+k;
if(k==0)
{
dp[i][j]=1;
}
else if(k==1)
{
dp[i][j]=2+(s[i]==s[j]);
}
else
{
dp[i][j]=(dp[i+1][j]+dp[i][j-1]-dp[i+1][j-1]+mod)%mod;
if(s[i]==s[j])
dp[i][j]+=dp[i+1][j-1]+1;
}
}
}
printf("Case %d: %d\n",cas++,dp[0][len-1]%mod);
}
return 0;
}

  • 动态规划
  • hdu
  • 算法竞赛

展开全文 >>

[转]高级数据结构设计--并查集及实现学习笔记(有趣篇)

9月 16

高级数据结构设计--并查集及实现学习笔记(有趣篇)





并查集的程序设计:


 

为了解释并查集的原理,我将举一个更有趣的例子。
话说江湖上散落着各式各样的大侠,有上千个之多。他们没有什么正当职业,整天背着剑在外面走来走去,碰到和自己不是一路人的,就免不了要打一架。但大侠们有一个优点就是讲义气,绝对不打自己的朋友。而且他们信奉“朋友的朋友就是我的朋友”,只要是能通过朋友关系串联起来的,不管拐了多少个弯,都认为是自己人。这样一来,江湖上就形成了一个一个的群落,通过两两之间的朋友关系串联起来。而不在同一个群落的人,无论如何都无法通过朋友关系连起来,于是就可以放心往死了打。但是两个原本互不相识的人,如何判断是否属于一个朋友圈呢?我们可以在每个朋友圈内推举出一个比较有名望的人,作为该圈子的代表人物,这样,每个圈子就可以这样命名“齐达内朋友之队”“罗纳尔多朋友之队”……两人只要互相对一下自己的队长是不是同一个人,就可以确定敌友关系了。
但是还有问题啊,大侠们只知道自己直接的朋友是谁,很多人压根就不认识队长,要判断自己的队长是谁,只能漫无目的的通过朋友的朋友关系问下去:“你是不是队长?你是不是队长?”这样一来,队长面子上挂不住了,而且效率太低,还有可能陷入无限循环中。于是队长下令,重新组队。队内所有人实行分等级制度,形成树状结构,我队长就是根节点,下面分别是二级队员、三级队员。每个人只要记住自己的上级是谁就行了。遇到判断敌友的时候,只要一层层向上问,直到最高层,就可以在短时间内确定队长是谁了。由于我们关心的只是两个人之间是否连通,至于他们是如何连通的,以及每个圈子内部的结构是怎样的,甚至队长是谁,并不重要。所以我们可以放任队长随意重新组队,只要不搞错敌友关系就好了。于是,门派产生了。


下面我们来看并查集的实现。
int pre[1000];
这个数组,记录了每个大侠的上级是谁。大侠们从1或者0开始编号(依据题意而定),pre[15]=3就表示15号大侠的上级是3号大侠。如果一个人的上级就是他自己,那说明他就是掌门人了,查找到此为止。也有孤家寡人自成一派的,比如欧阳锋,那么他的上级就是他自己。每个人都只认自己的上级。比如胡青牛同学只知道自己的上级是杨左使。张无忌是谁?不认识!要想知道自己的掌门是谁,只能一级级查上去。
find这个函数就是找掌门用的,意义再清楚不过了(路径压缩算法先不论,后面再说)。








 

再来看看join函数,就是在两个点之间连一条线,这样一来,原先它们所在的两个板块的所有点就都可以互通了。这在图上很好办,画条线就行了。但我们现在是用并查集来描述武林中的状况的,一共只有一个pre[]数组,该如何实现呢?
还是举江湖的例子,假设现在武林中的形势如图所示。虚竹小和尚与周芷若MM是我非常喜欢的两个人物,他们的终极boss分别是玄慈方丈和灭绝师太,那明显就是两个阵营了。我不希望他们互相打架,就对他俩说:“你们两位拉拉勾,做好朋友吧。”他们看在我的面子上,同意了。这一同意可非同小可,整个少林和峨眉派的人就不能打架了。这么重大的变化,可如何实现呀,要改动多少地方?其实非常简单,我对玄慈方丈说:“大师,麻烦你把你的上级改为灭绝师太吧。这样一来,两派原先的所有人员的终极boss都是师太,那还打个球啊!反正我们关心的只是连通性,门派内部的结构不要紧的。”玄慈一听肯定火大了:“我靠,凭什么是我变成她手下呀,怎么不反过来?我抗议!”抗议无效,上天安排的,最大。反正谁加入谁效果是一样的,我就随手指定了一个。这段函数的意思很明白了吧?

 



 

再来看看路径压缩算法。建立门派的过程是用join函数两个人两个人地连接起来的,谁当谁的手下完全随机。最后的树状结构会变成什么胎唇样,我也完全无法预计,一字长蛇阵也有可能。这样查找的效率就会比较低下。最理想的情况就是所有人的直接上级都是掌门,一共就两级结构,只要找一次就找到掌门了。哪怕不能完全做到,也最好尽量接近。这样就产生了路径压缩算法。
设想这样一个场景:两个互不相识的大侠碰面了,想知道能不能揍。
于是赶紧打电话问自己的上级:“你是不是掌门?”
上级说:“我不是呀,我的上级是谁谁谁,你问问他看看。”
一路问下去,原来两人的最终boss都是东厂曹公公。
“哎呀呀,原来是记己人,西礼西礼,在下三营六组白面葫芦娃!”
“幸会幸会,在下九营十八组仙子狗尾巴花!”
两人高高兴兴地手拉手喝酒去了。
“等等等等,两位同学请留步,还有事情没完成呢!”我叫住他俩。
“哦,对了,还要做路径压缩。”两人醒悟。
白面葫芦娃打电话给他的上级六组长:“组长啊,我查过了,其习偶们的掌门是曹公公。不如偶们一起及接拜在曹公公手下吧,省得级别太低,以后查找掌门麻环。”
“唔,有道理。”
白面葫芦娃接着打电话给刚才拜访过的三营长……仙子狗尾巴花也做了同样的事情。
这样,查询中所有涉及到的人物都聚集在曹公公的直接领导下。每次查询都做了优化处理,所以整个门派树的层数都会维持在比较低的水平上。路径压缩的代码,看得懂很好,看不懂也没关系,直接抄上用就行了。总之它所实现的功能就是这么个意思。



 

 

提到并查集就不得不提并查集最经典的例子:食物链。
POJ 1182 食物链
http://acm.pku.edu.cn/JudgeOnline/problem?id=1182
题目告诉有3种动物,互相吃与被吃,现在告诉你m句话,其中有真有假,叫你判断假的个数(如果前面没有与当前话冲突的,即认为其为真话)
这题有几种做法,我以前的做法是每个集合(或者称为子树,说集合的编号相当于子树的根结点,一个概念)中的元素都各自分为A, B, C三类,在合并时更改根结点的种类,其他点相应更改偏移量。但这种方法公式很难推,特别是偏移量很容易计算错误。
下面来介绍一种通用且易于理解的方法:
首先,集合里的每个点我们都记录它与它这个集合(或者称为子树)的根结点的相对关系relation。0表示它与根结点为同类,1表示它吃根结点,2表示它被根结点吃。
那么判断两个点a, b的关系,我们令p = Find(a), q = Find(b),即p, q分别为a, b子树的根结点。
1. 如果p != q,说明a, b暂时没有关系,那么关于他们的判断都是正确的,然后合并这两个子树。这里是关键,如何合并两个子树使得合并后的新树能保证正确呢?这里我们规定只能p合并到q(刚才说过了,启发式合并的优化效果并不那么明显,如果我们用启发式合并,就要推出两个式子,而这个推式子是件比较累的活…所以一般我们都规定一个子树合到另一个子树)。那么合并后,p的relation肯定要改变,那么改成多少呢?这里的方法就是找规律,列出部分可能的情况,就差不多能推出式子了。这里式子为 : tree[p].relation = (tree[b].relation - tree[a].relation + 2 + d) % 3; 这里的d为判断语句中a, b的关系。还有个问题,我们是否需要遍历整个a子树并更新每个结点的状态呢?答案是不需要的,因为我们可以在Find()函数稍微修改,即结点x继承它的父亲(注意是前父亲,因为路径压缩后父亲就会改变),即它会继承到p结点的改变,所以我们不需要每个都遍历过去更新。
2. 如果p = q,说明a, b之前已经有关系了。那么我们就判断语句是否是对的,同样找规律推出式子。即if ( (tree[b].relation + d + 2) % 3 != tree[a].relation ), 那么这句话就是错误的。
3. 再对Find()函数进行些修改,即在路径压缩前纪录前父亲是谁,然后路径压缩后,更新该点的状态(通过继承前父亲的状态,这时候前父亲的状态是已经更新的)。
核心的两个函数为:
int Find(int x)
{
int temp_p;
if (tree[x].parent != x)
{
// 因为路径压缩,该结点的与根结点的关系要更新(因为前面合并时可能还没来得及更新).
temp_p = tree[x].parent;
tree[x].parent = Find(tree[x].parent);
// x与根结点的关系更新(因为根结点变了),此时的temp_p为它原来子树的根结点.
tree[x].relation = (tree[x].relation + tree[temp_p].relation) % 3;
}
return tree[x].parent;
}

void Merge(int a, int b, int p, int q, int d)
{
// 公式是找规律推出来的.
tree[p].parent = q; // 这里的下标相同,都是tree[p].
tree[p].relation = (tree[b].relation - tree[a].relation + 2 + d) % 3;
}

而这种纪录与根结点关系的方法,适用于几乎所有的并查集判断关系(至少我现在没遇到过不适用的情况…可能是自己做的还太少了…),所以向大家强烈推荐~~

搞定了食物链这题,基本POJ上大部分基础并查集题目就可以顺秒了,这里仅列个题目编号: POJ 1308 1611 1703 1988 2236 2492 2524。

下面来讲解几道稍微提高点的题目:
POJ 1456 Supermarket
http://acm.pku.edu.cn/JudgeOnline/problem?id=1456
这道题贪心的思想很明显,不过O(n^2)的复杂度明显不行,我们可以用堆进行优化,这里讲下并查集的优化方法(很巧妙)。我们把连续的被占用的区间看成一个集合(子树),它的根结点为这个区间左边第一个未被占用的区间。
先排序,然后每次判断Find(b[i])是否大于0,大于0说明左边还有未被占用的空间,则占用它,然后合并(b[i], Find(b[i]) – 1)即可。同样这里我们规定只能左边的子树合并到右边的子树(想想为什么~~)。

POJ 1733 Parity game
http://acm.pku.edu.cn/JudgeOnline/problem?id=1733
这题同样用类似食物链的思想。
首先我们先离散化,因为原来的区间太大了(10^9),我们可以根据问题数目离散成(10^4)。我们要理解,这里的离散化并不影响最终的结果,因为区间里1的奇偶个数与区间的大小无关(这句话有点奇怪,可以忽略…),然后每次输入a, b,我们把b++,如果他俩在一个集合内,那么区间[a, b]里1的个数相当于b.relation ^ a.relation,判断对错即可。如果不在一个集合内,合并集合(这里我们规定根结点小的子树合并根结点大的,所以要根据不同情况推式子),修改子树的根结点的状态,子树的其他结点状态通过Find()函数来更新。

hdu 3038 How Many Answers Are Wrong
http://acm.hdu.edu.cn/showproblem.php?pid=3038
上面那题的加强版,不需要离散化,因为区间的和与区间的大小有关(和上面的那句话对比下,同样可以忽略之…),做法与上面那题差不多,只是式子变了,自己推推就搞定了。但这题还有个条件,就是每个点的值在[0, 100]之间,那么如果a, b不在一个子树内,我们就合并,但在合并之前还要判断合并后会不会使得区间的和不合法,如果会说明该合并是非法的,那么就不合并,同样认为该句话是错误的。

POJ 1417 True Liars(难)
http://acm.pku.edu.cn/JudgeOnline/problem?id=1417
并查集 + DP(或搜索)。
题目中告诉两种人,一种只说真话,一种只说假话。然后告诉m条语句,问是否能判断哪些人是只说真话的那类人。
其实并查集部分跟食物链还是相似,而且种类变少了一种,更容易了。我们可以通过并查集把有关系的一些人合并到一个集合内(具体方法参见食物链讲解)。
现在的问题转化为,有n个集合,每个集合都有a, b连个数字,现在要求n个集合中各跳出一个数(a或者b),使得他们之和等于n1(说真话的人数)。而这个用dp可以很好的解决,用f[i][j]表示到第i个集合和为j个的情况数,我们还用过pre[i][j]记录当前选的是a还是b,用于后面判断状态。方程为f[i][j] = f[i – 1][j – a] + f[i – 1][j – b], j >= a, j >= b。如果最后f[n][n1] == 1说明是唯一的情况,输出该情况,否则输出 “no”(多解算no)
注意点 :
1. 这题的m, n1, n2都有可能出现0,可以特殊处理,也可以一起处理。
2. 按上面的dp写法,f[i][j]可能会很大,因为n可以达到三位数。其实我们关心的只是f[i][j] 等于0,等于1,大于1三种情况,所以当f[i][j] > 1时,我们都让它等于2即可。

POJ 2912 Rochambeau(难)
http://acm.pku.edu.cn/JudgeOnline/problem?id=2912
Baidu Star 2006 Preliminary的题目,感觉出的很好,在并查集题目中算是较难的了。其实这题跟食物链完全一个磨子,同样三类食物,同样的互相制约关系。所以食物链代码拿过来改都不需要改。但这题有个judge,他可以出任意手势。于是我们的做法是,枚举每个小孩为judge,判断他为judge时在第几句话出错erri。
1. 如果只有1个小孩是judge时全部语句都是正确的,说明该小孩是judge,那么判断的句子数即为其他小孩的err[i]的最大值。如果
2. 如果每个小孩的都不是judge(即都可以找到出错的语句),那么就是impossible。
3. 多于1个小孩是judge时没有找到出错的语句,就是Can not determine。

ZOJ 3261 Connections in Galaxy War http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=3563
nuaa 1087 联通or不连通
http://acm.nuaa.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1087
两题做法差不多,都是反过来的并查集题目,先对边集排序,然后把要删去的边从二分在边集中标记。然后并查集连接没有标记的边集,再按查询反向做就可。第一题合并结点时按照题目要求的优先级合并即可。

这里介绍的并查集题目,主要都是处理些集合之间的关系(这是并查集的看家本领~~),至于并查集还有个用处就在求最小生成树的Kruskal算法中,那个是图论中求最小生成树的问题(一般这个难点不在于并查集,它只是用于求最小生成树的一种方法),就不在这里赘述了~~

分享来自Tina_Z_Y和czyuan 感谢两个牛人!


  • 数据结构
  • 并查集
  • 算法
  • 学习笔记

展开全文 >>

Linux命令之Crontab学习笔记

9月 16

crontab介绍

crontab是unix下设置周期性执行任务的工具,类似于windows的计划任务。当系统启动时会自动启动cron进程并后台运行,系统每分钟就启动一次cron服务并检查是否有可执行的任务,若有则会自动执行该任务。

安装crond服务

Linux系统一般都默认安装有crond服务,可跳过该步

安装crond服务

1
2
yum install vixie-cron  #vixie-cron是cron主程序
yum install crontabs #crontabs软件包是用来安装、卸装、或列举用来驱动 cron 守护进程的表格的程序

启动crond服务

1
service crond start

查看crond服务是否启动

1
service crond status

设置开机启动

1
chkconfig crond on

more >>
  • Linux
  • crontab
  • 学习笔记

展开全文 >>

poj1006 中国剩余定理

9月 16

很明显这题要求的是使等式 x+d=pmod23=emod28=imod33 成立的最小的x,注意x不能为0

注意,有几组特殊数据供参考

  • 24 29 34 0 1
  • 24 29 34 1 21252
  • 24 29 34 2 21251
  • 0 0 0 0 21252

关于中国剩余定理,我理解的也不是很好,直接套的模板

poj1006 Biorhythmsview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <iostream>  
using namespace std;

int Extended_Euclid(int a,int b,int &x,int &y) //扩展欧几里得算法
{
int d;
if(b==0)
{
x=1;y=0;
return a;
}
d=Extended_Euclid(b,a%b,y,x);
y-=a/b*x;
return d;
}

int Chinese_Remainder(int a[],int w[],int len) //中国剩余定理 a[]存放余数 w[]存放两两互质的数
{
int i,d,x,y,m,n,ret;
ret=0;
n=1;
for (i=0;i<len;i++)
n*=w[i];
for (i=0;i<len;i++)
{
m=n/w[i];
d=Extended_Euclid(w[i],m,x,y);
ret=(ret+y*m*a[i])%n;
}
return (n+ret%n)%n;
}

int main()
{
int n;
int w[3],a[]={23,28,33};
int k = 1;
while (~scanf("%d%d%d%d",&w[0],&w[1],&w[2],&n))
{
if ( w[0]==-1&&w[1]==-1&&w[2]==-1&&n==-1)
break;
int t = Chinese_Remainder(w,a,3) - n ; //引用中国剩余定理
t=t % ( 23 * 28 * 33 ) ;
if ( t <= 0 )
t += 23 * 28 * 33 ;
printf("Case %d: the next triple peak occurs in ",k) ;
printf("%d days.\n",t);
k++;
}
return 0;
}
  • 数论
  • poj
  • 中国剩余定理
  • 算法竞赛

展开全文 >>

« Prev1…34567…13Next »
© 2018 永夜初晗
Hexo Theme Yilia by Litten
  • 所有文章
  • 友链
  • 关于我

tag:

  • 算法竞赛入门经典训练指南
  • 动态规划
  • 排序
  • 计算几何
  • 贪心
  • 离散
  • 二分
  • 深度优先搜索
  • 递归
  • 状态压缩
  • codeforces
  • 最大公约数
  • 数论
  • 矩阵
  • 快速幂
  • 素性测试
  • 素数
  • burnside
  • polya
  • AC自动机
  • kmp
  • 字典树
  • 字符串匹配
  • 数据结构
  • 欧拉函数
  • 筛选
  • hdu
  • 并查集
  • 线段树
  • 仙剑
  • 感动
  • 语录
  • 背包问题
  • 优先队列
  • 枚举
  • 后缀数组
  • 旋转
  • 卡特兰数
  • 广度优先搜索
  • 最短路
  • 二分图
  • 图论
  • 最大匹配
  • 算法
  • poj
  • 中国剩余定理
  • 矩形
  • 分治
  • 规律
  • Linux
  • crontab
  • 同余方程
  • 扩展欧几里得
  • 记忆化搜索
  • floyd
  • prim
  • 生成树
  • 费马小定理
  • kruskal
  • 位运算
  • 高斯消元
  • 匈牙利算法
  • 最小覆盖点
  • 搜索
  • 最长公共子序列
  • DP
  • 队列
  • 排列
  • 组合数学
  • 最小生成树
  • 抽屉原理
  • 高精度
  • 欧几里得
  • 斐波那契数列
  • 法雷级数
  • usaco
  • 测试数据
  • 二叉树
  • 矩形切割
  • 阶乘
  • spfa
  • 背包
  • 欧拉回路
  • 康托展开
  • zoj
  • 反素数
  • 归并排序
  • 逆序对

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录(注意不是yilia根目录)执行以下命令:
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置:

      jsonContent:
        meta: false
        pages: false
        posts:
          title: true
          date: true
          path: true
          text: false
          raw: false
          content: false
          slug: false
          updated: false
          comments: false
          link: false
          permalink: false
          excerpt: false
          categories: false
          tags: true
    

  • 《算法竞赛入门经典训练指南》动态规划习题1

    2018-09-16

    #算法竞赛入门经典训练指南#动态规划

  • 《算法竞赛入门经典训练指南》动态规划习题2

    2018-09-16

    #算法竞赛入门经典训练指南#动态规划

  • 《算法竞赛入门经典训练指南》高效算法设计举例1

    2018-09-16

    #算法竞赛入门经典训练指南#排序#计算几何#贪心

  • 《算法竞赛入门经典训练指南》高效算法设计举例2

    2018-09-16

    #算法竞赛入门经典训练指南#动态规划#离散#二分

  • 《算法竞赛入门经典训练指南》问题求解常见策略1

    2018-09-16

    #算法竞赛入门经典训练指南#深度优先搜索#递归

  • 《算法竞赛入门经典训练指南》问题求解常见策略2

    2018-09-16

    #算法竞赛入门经典训练指南#二分#深度优先搜索

  • 《算法竞赛入门经典训练指南》动态规划专题1

    2018-09-16

    #算法竞赛入门经典训练指南#动态规划#递归#状态压缩

  • 《算法竞赛入门经典训练指南》动态规划专题2

    2018-09-16

    #算法竞赛入门经典训练指南#动态规划#状态压缩

  • 《算法竞赛入门经典训练指南》思维的体操

    2018-09-16

    #算法竞赛入门经典训练指南#贪心#数论

  • 20111120周赛解题报告

    2018-09-16

    #最大公约数#数论

  • Codeforces Round #118 (Div. 2) :A. Comparing Strings

    2018-09-16

    #codeforces

  • Codeforces Round #118 (Div. 2) :B. Growing Mushrooms

    2018-09-16

    #codeforces

  • Codeforces Round #118 (Div. 2) :C. Plant

    2018-09-16

    #codeforces#矩阵#快速幂

  • Codeforces Round #118 (Div. 2) :D. Mushroom Scientists

    2018-09-16

    #codeforces#数论

  • AC自动机简单模版

    2018-09-16

    #AC自动机#kmp#字典树#字符串匹配#数据结构

  • 欧拉函数模板

    2018-09-16

    #素数#欧拉函数#筛选

  • 矩阵快速幂模板

    2018-09-16

    #矩阵#快速幂

  • burnside定理,polya计数 模版

    2018-09-16

    #burnside#polya

  • 素性测试 miller rabin+pollard rho

    2018-09-16

    #素性测试#素数

  • 潸然泪下 盘点仙剑十大让人动情女子

    2018-09-16

    #仙剑#感动

  • 仙剑四十大感人经典语录

    2018-09-16

    #仙剑#感动#语录

  • hdu1016 Prime Ring Problem解题报告

    2018-09-16

    #深度优先搜索#素数#hdu

  • hdu1232 畅通工程 解题报告

    2018-09-16

    #数据结构#hdu#并查集

  • hdu1247 Hat’s Words 解题报告

    2018-09-16

    #字典树#数据结构#hdu

  • hdu1604 Deque 2013多校第一场1005

    2018-09-16

    #动态规划#hdu

  • hdu1711 Number Sequence 解题报告

    2018-09-16

    #kmp#hdu

  • hdu1754 I Hate It 解题报告

    2018-09-16

    #数据结构#hdu#线段树

  • hdu1785 You Are All Excellent

    2018-09-16

    #数论#hdu

  • hdu1896 Stones 解题报告

    2018-09-16

    #hdu#优先队列

  • hdu2036和hdu2108 叉乘的运用

    2018-09-16

    #计算几何#hdu

  • hdu2222 Keywords Search 解题报告

    2018-09-16

    #AC自动机#kmp#数据结构#hdu

  • hdu2955 Robberies 教你怎样抢银行划算!

    2018-09-16

    #动态规划#hdu#背包问题

  • hdu2971 Tower 矩阵快速幂

    2018-09-16

    #递归#矩阵#快速幂#hdu

  • hdu4161 Iterated Difference 解题报告

    2018-09-16

    #hdu#枚举

  • hdu4162 Shape Number 解题报告

    2018-09-16

    #数据结构#hdu#枚举#后缀数组#旋转

  • hdu4163 Stock Prices 解题报告

    2018-09-16

    #排序#hdu

  • hdu4165 Pills 解题报告

    2018-09-16

    #递归#数论#hdu#卡特兰数

  • hdu4291 A Short problem 矩阵快速幂 成都区预赛的一题

    2018-09-16

    #矩阵#快速幂#hdu

  • hdu4300 Clairewd’s message 多校第一场

    2018-09-16

    #kmp#hdu

  • hdu4301 Divide Chocolate 动态规划解题报告(多校1)

    2018-09-16

    #动态规划#hdu

  • hdu4308 Saving Princess claire 搜索解题报告(多校1)

    2018-09-16

    #hdu#广度优先搜索#最短路

  • hdu4412 Sky Soldiers 动态规划 杭州网赛的第三题

    2018-09-16

    #动态规划#hdu

  • hdu4419 Colourful Rectangle 搜索+矩形分割 杭州赛区网赛最后一题

    2018-09-16

    #深度优先搜索#hdu#矩形#分治

  • hdu4602 Partition 2013多校第一场100

    2018-09-16

    #递归#数论#hdu

  • hdu4611 Balls Rearrangement 最大公约数 2013多校2-1001

    2018-09-16

    #最大公约数#数论#hdu

  • hdu4619 Warm up 2 二分图匹配 2013多校第二场1009

    2018-09-16

    #贪心#hdu#二分图#图论#最大匹配

  • hdu4632 Palindrome subsequence 20103多校4-1001

    2018-09-16

    #动态规划#hdu

  • [转]高级数据结构设计--并查集及实现学习笔记(有趣篇)

    2018-09-16

    #数据结构#并查集#算法

  • Linux命令之Crontab学习笔记

    2018-09-16

    #Linux#crontab

  • poj1006 中国剩余定理

    2018-09-16

    #数论#poj#中国剩余定理

  • POJ1019 ---简单的数学找规律题

    2018-09-16

    #递归#poj#规律

  • poj1050经典DP的二维形式

    2018-09-16

    #动态规划#poj

  • 通过POJ1061青蛙的约会来谈扩展欧几里得算法

    2018-09-16

    #数论#poj#同余方程#扩展欧几里得

  • POJ 1062 昂贵的聘礼 解题报告

    2018-09-16

    #最短路#图论#poj

  • poj1080 人类基因配对

    2018-09-16

    #动态规划#poj

  • poj1088记忆化搜索

    2018-09-16

    #poj#记忆化搜索

  • POJ 1125 Stockbroker Grapevine 解题报告

    2018-09-16

    #最短路#图论#poj#floyd

  • poj1141 Brackets Sequence(经典DP) 解题报告另附官方测试数据

    2018-09-16

    #动态规划#字符串匹配#poj

  • POJ1142Smith Numbers一道简单的数学题

    2018-09-16

    #数论#poj

  • poj1191棋盘分割(动态规划)

    2018-09-16

    #动态规划#poj

  • POJ1222EXTENDED LIGHTS OUT 解题报告

    2018-09-16

    #枚举#poj#位运算#高斯消元

  • POJ1251 Jungle Roads 解题报告

    2018-09-16

    #图论#poj#生成树#kruskal

  • POJ1258 Agri-Net 解题报告

    2018-09-16

    #图论#poj#prim#生成树

  • POJ 1274 The Perfect Stall 解题报告

    2018-09-16

    #二分图#最大匹配#poj#匈牙利算法

  • poj1284 欧拉函数的运用

    2018-09-16

    #最大公约数#数论#欧拉函数#poj#费马小定理

  • POJ1321 棋盘问题 解题报告

    2018-09-16

    #深度优先搜索#poj#搜索

  • POJ 1325 Machine Schedule 解题报告

    2018-09-16

    #图论#poj#最小覆盖点

  • POJ1390 Blocks 常见动态规划模型

    2018-09-16

    #动态规划#poj#DP

  • POJ1426 Find The Multiple 解题报告

    2018-09-16

    #深度优先搜索#数论#poj#搜索

  • poj1458 最长公共子序列问题

    2018-09-16

    #动态规划#poj#最长公共子序列

  • POJ 1469 COURSES 解题报告

    2018-09-16

    #二分图#图论#最大匹配#poj

  • poj1579 Function Run Fun 解题报告

    2018-09-16

    #poj#记忆化搜索

  • POJ1681 Painter's Problem 解题报告

    2018-09-16

    #枚举#poj#位运算#高斯消元

  • POJ 1789 Truck History 解题报告

    2018-09-16

    #图论#poj#prim#生成树

  • POJ 1797 Heavy Transportation 解题报告

    2018-09-16

    #并查集#最短路#图论#poj#生成树

  • POJ1830 开关问题 解题报告

    2018-09-16

    #poj#位运算#高斯消元

  • poj2115 同余方程与扩展欧几里得

    2018-09-16

    #poj#中国剩余定理#同余方程#扩展欧几里得

  • POJ2249--一道简单的排列组合题

    2018-09-16

    #数论#poj#排列#组合数学

  • POJ2689 Prime Distance 素数筛选

    2018-09-15

    #素数#筛选#poj

  • POJ2251 Dungeon Master 解题报告

    2018-09-15

    #数据结构#广度优先搜索#poj#搜索#队列

  • POJ 2253 Frogger 解题报告

    2018-09-15

    #最短路#图论#poj#生成树

  • POJ2262Goldbach's Conjecture 简单的素数判定

    2018-09-15

    #素数#枚举#poj

  • 从poj2356来体会 抽屉原理 的妙用

    2018-09-15

    #数论#poj#抽屉原理

  • POJ2407Relatives --欧拉函数的简单运用

    2018-09-15

    #素数#欧拉函数#poj

  • poj2409 Let it Bead 解题报告

    2018-09-15

    #polya#poj#组合数学

  • poj2478 又一欧拉公式的运用

    2018-09-15

    #数论#欧拉函数#poj

  • poj2479与poj2593,同一道DP题

    2018-09-15

    #动态规划#poj

  • POJ 2485 Highways 解题报告

    2018-09-15

    #图论#poj#最小生成树

  • POJ2488 A Knight's Journey 解题报告

    2018-09-14

    #深度优先搜索#poj#搜索

  • poj 2492 并查集

    2018-09-14

    #数据结构#并查集#poj

  • POJ 2506 高精度+递推

    2018-09-14

    #递归#poj#高精度

  • poj2663 Tri Tiling 解题报告

    2018-09-14

    #递归#数论#poj

  • POJ 2773 互素问题

    2018-09-14

    #数论#素数#poj

  • poj 2891 Strange Way to Express Integers 扩展欧几里得

    2018-09-14

    #最大公约数#数论#poj#扩展欧几里得#欧几里得

  • POJ3009Curling 2.0解题报告

    2018-09-14

    #深度优先搜索#poj#搜索

  • poj3070来体会矩阵的妙用

    2018-09-14

    #矩阵#快速幂#poj#斐波那契数列

  • poj3090 欧拉函数与法雷级数

    2018-09-14

    #数论#欧拉函数#poj#法雷级数

  • POJ3185 The Water Bowls 解题报告

    2018-09-14

    #枚举#poj#位运算#高斯消元

  • poj3233 又见矩阵,不过是等比吗?

    2018-09-14

    #数论#矩阵#poj#分治

  • POJ3278 Catch That Cow 解题报告

    2018-09-14

    #数据结构#广度优先搜索#poj#搜索

  • poj3370同样的是抽屉原理

    2018-09-14

    #数论#poj#抽屉原理

  • USACO 2.2.2 Subset Sums解题报告

    2018-09-14

    #动态规划#递归#记忆化搜索#usaco

  • POJ测试数据及官方标程,你能HOLD住吗?

    2018-09-14

    #poj#测试数据

  • USACO 2.2.3 Runaround Numbers解题报告

    2018-09-14

    #枚举#usaco

  • USACO 2.2.4 Party Lamps 解题报告

    2018-09-14

    #枚举#规律#搜索#usaco

  • USACO 2.3.1 Longest Prefix 解题报告

    2018-09-14

    #动态规划#字典树#数据结构#usaco

  • USACO 2.3.2 Cow Pedigrees 解题报告

    2018-09-14

    #动态规划#usaco#二叉树

  • USACO 2.3.3 Zero Sum 解题报告

    2018-09-14

    #深度优先搜索#枚举#usaco

  • USACO 2.3.4 Money Systems 解题报告

    2018-09-14

    #动态规划#usaco

  • USACO 2.3.5 Controlling Companies 解题报告

    2018-09-14

    #图论#usaco

  • USACO 3.1.4 Shaping Regions 搜索+矩形切割

    2018-09-14

    #深度优先搜索#矩形#分治#usaco#矩形切割

  • USACO 3.1.5 Contact 解题报告

    2018-09-14

    #字典树#usaco

  • USACO 3.1.6 Stamps(动态规划)解题报告

    2018-09-14

    #动态规划#usaco#背包

  • USACO 3.2.1 Factorials 求n!最后非零数(初级)

    2018-09-14

    #数论#usaco#阶乘

  • USACO 3.2.2 Stringsobits 解题报告

    2018-09-14

    #组合数学#usaco

  • USACO 3.2.3 Spinning Wheels

    2018-09-14

    #枚举#usaco

  • USACO 3.2.4 Feed Ratios 解题报告

    2018-09-14

    #高斯消元#usaco

  • USACO 3.2.5 Magic Squares (BFS+康托展开)

    2018-09-14

    #广度优先搜索#usaco#康托展开

  • USACO 3.2.6 Sweet Butter(SPFA求最短路)

    2018-09-14

    #usaco#spfa

  • USACO 3.3.1 Riding The Fences 欧拉回路

    2018-09-14

    #usaco#欧拉回路

  • ZOJ 2562 More Divisors 反素数

    2018-09-14

    #素数#zoj#反素数

  • ZOJ 3574 Under Attack II解题报告

    2018-09-14

    #矩形#zoj#归并排序#逆序对

  • ZOJ月赛解题报告-ZOJ Monthly, February 2012(ZOJ3571-3580)

    2018-09-14

    #最大公约数#数论#矩阵#数据结构#zoj

  • weibo
  • github
小龙少,年二十有二。始从文,连考而不中。遂习武,练武场上发一矢,中鼓吏,逐之出。改学IT,自建一变量,用之,烫烫烫烫烫烫烫烫烫烫!