P1636 Einstein学画画
题目描述
Einstein 学起了画画。
此人比较懒~~，他希望用最少的笔画画出一张画……
给定一个无向图，包含 n n n 个顶点（编号 1 ∼ n 1 \sim n 1∼n）， m m m 条边，求最少用多少笔可以画出图中所有的边。
输入格式
第一行两个整数 n , m n, m n,m。
接下来 m m m 行，每行两个数 a , b a, b a,b（ a ≠ b a \ne b a=b），表示 a , b a, b a,b 两点之间有一条边相连。
一条边不会被描述多次。
输出格式
一个数，即问题的答案。
样例 #1
样例输入 #1
5 5
2 3
2 4
2 5
3 4
4 5
样例输出 #1
1
提示
对于 50 % 50 \% 50% 的数据， n ≤ 50 n \le 50 n≤50， m ≤ 100 m \le 100 m≤100。
对于 100 % 100\% 100% 的数据， 1 ≤ n ≤ 1000 1 \le n \le 1000 1≤n≤1000， 1 ≤ m ≤ 10 5 1 \le m \le {10}^5 1≤m≤105。
思路
先判断欧拉路，然后我们可以发现若每多出两个奇点，那么画的次数就会+1，又因为连通图只可能有偶数个奇点，所以答案为ans/2，最后记得特判
代码
#include<bits/stdc++.h>
using namespace std;
int n,m,cnt[1005],ans;
int main(){
cin>>n>>m;
for(int i=1;i<=m;i++){
int x,y;
cin>>x>>y;
cnt[x]++;
cnt[y]++;
}
for(int i=1;i<=n;i++)
if(cnt[i]&1==1) ans++;
if(ans==0) cout<<1<<endl;
else cout<<ans/2<<endl;
return 0;
}
P8654 [蓝桥杯 2017 国 C] 合根植物
题目描述
w 星球的一个种植园，被分成 m × n m \times n m×n 个小格子（东西方向 m m m 行，南北方向 n n n 列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。
如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
输入格式
第一行，两个整数 m m m， n n n，用空格分开，表示格子的行数、列数（ 1 < m , n < 1000 1<m,n<1000 1<m,n<1000）。
接下来一行，一个整数 k k k，表示下面还有 k k k 行数据 ( 0 < k < 1 0 5 ) (0<k<10^5) (0<k<105)。
接下来 k k k 行，第行两个整数 a a a， b b b，表示编号为 a a a 的小格子和编号为 b b b 的小格子合根了。
格子的编号一行一行，从上到下，从左到右编号。
比如： 5 × 4 5 \times 4 5×4 的小格子，编号：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20
输出格式
一行一个整数，表示答案
样例 #1
样例输入 #1
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17
样例输出 #1
5
提示
样例解释
时限 1 秒, 256M。蓝桥杯 2017 年第八届国赛
思路
直接套并查集模板
代码
#include<bits/stdc++.h>
using namespace std;
int m,n,k,fa[1000005],ans;
bool vis[1000005];
int getfa(int x)
{
return fa[x] == x ? x : (fa[x] = getfa(fa[x]));
}
void merge(int x, int y)
{
fa[getfa(x)] = getfa(y);
}
bool check(int x, int y)
{
return getfa(x) == getfa(y);
}
int main()
{
cin>>m>>n>>k;
for(int i=1;i<=m*n;i++) fa[i]=i;
for(int i=0;i<k;i++)
{
int a,b;
cin>>a>>b;
merge(a,b);
}
for(int i=1;i<=m*n;i++)
{
if(!vis[getfa(i)])
{
vis[getfa(i)]=true;
ans++;
}
}
cout<<ans;
return 0;
}
P3958 [NOIP2017 提高组] 奶酪
题目背景
NOIP2017 提高组 D2T1
题目描述
现有一块大奶酪，它的高度为 h h h，它的长度和宽度我们可以认为是无限大的，奶酪中间有许多半径相同的球形空洞。我们可以在这块奶酪中建立空间坐标系，在坐标系中，奶酪的下表面为 z = 0 z = 0 z=0，奶酪的上表面为 z = h z = h z=h。
现在，奶酪的下表面有一只小老鼠 Jerry，它知道奶酪中所有空洞的球心所在的坐标。如果两个空洞相切或是相交，则 Jerry 可以从其中一个空洞跑到另一个空洞，特别地，如果一个空洞与下表面相切或是相交，Jerry 则可以从奶酪下表面跑进空洞；如果一个空洞与上表面相切或是相交，Jerry 则可以从空洞跑到奶酪上表面。
位于奶酪下表面的 Jerry 想知道，在不破坏奶酪的情况下，能否利用已有的空洞跑 到奶酪的上表面去?
空间内两点 P 1 ( x 1 , y 1 , z 1 ) P_1(x_1,y_1,z_1) P1(x1,y1,z1)、 P 2 ( x 2 , y 2 , z 2 ) P2(x_2,y_2,z_2) P2(x2,y2,z2) 的距离公式如下：
d i s t ( P 1 , P 2 ) = ( x 1 − x 2 ) 2 + ( y 1 − y 2 ) 2 + ( z 1 − z 2 ) 2 \mathrm{dist}(P_1,P_2)=\sqrt{(x_1-x_2)^2+(y_1-y_2)^2+(z_1-z_2)^2} dist(P1,P2)=(x1−x2)2+(y1−y2)2+(z1−z2)2
输入格式
每个输入文件包含多组数据。
第一行，包含一个正整数 T T T，代表该输入文件中所含的数据组数。
接下来是 T T T 组数据，每组数据的格式如下： 第一行包含三个正整数 n , h , r n,h,r n,h,r，两个数之间以一个空格分开，分别代表奶酪中空洞的数量，奶酪的高度和空洞的半径。
接下来的 n n n 行，每行包含三个整数 x , y , z x,y,z x,y,z，两个数之间以一个空格分开，表示空洞球心坐标为 ( x , y , z ) (x,y,z) (x,y,z)。
输出格式
T
T
T 行，分别对应
T
T
T 组数据的答案，如果在第
i
i
i 组数据中，Jerry 能从下表面跑到上表面，则输出 Yes，如果不能，则输出 No。
样例 #1
样例输入 #1
3
2 4 1
0 0 1
0 0 3
2 5 1
0 0 1
0 0 4
2 5 2
0 0 2
2 0 4
样例输出 #1
Yes
No
Yes
提示
【输入输出样例 1 1 1 说明】
第一组数据,由奶酪的剖面图可见：
第一个空洞在 ( 0 , 0 , 0 ) (0,0,0) (0,0,0) 与下表面相切；
第二个空洞在 ( 0 , 0 , 4 ) (0,0,4) (0,0,4) 与上表面相切；
两个空洞在 ( 0 , 0 , 2 ) (0,0,2) (0,0,2) 相切。
输出 Yes。
第二组数据,由奶酪的剖面图可见：
两个空洞既不相交也不相切。
输出 No。
第三组数据,由奶酪的剖面图可见：
两个空洞相交，且与上下表面相切或相交。
输出 Yes。
【数据规模与约定】
对于 20 % 20\% 20% 的数据， n = 1 n = 1 n=1， 1 ≤ h 1 \le h 1≤h， r ≤ 1 0 4 r \le 10^4 r≤104，坐标的绝对值不超过 1 0 4 10^4 104。
对于 40 % 40\% 40% 的数据， 1 ≤ n ≤ 8 1 \le n \le 8 1≤n≤8， 1 ≤ h 1 \le h 1≤h， r ≤ 1 0 4 r \le 10^4 r≤104，坐标的绝对值不超过 1 0 4 10^4 104。
对于 80 % 80\% 80% 的数据， 1 ≤ n ≤ 1 0 3 1 \le n \le 10^3 1≤n≤103， 1 ≤ h , r ≤ 1 0 4 1 \le h , r \le 10^4 1≤h,r≤104，坐标的绝对值不超过 1 0 4 10^4 104。
对于 100 % 100\% 100% 的数据， 1 ≤ n ≤ 1 × 1 0 3 1 \le n \le 1\times 10^3 1≤n≤1×103， 1 ≤ h , r ≤ 1 0 9 1 \le h , r \le 10^9 1≤h,r≤109， T ≤ 20 T \le 20 T≤20，坐标的绝对值不超过 1 0 9 10^9 109。
思路
先按高矮从小到大排序，如果一个洞能和它前面任何一个洞相连或是直接与下表面相连，就存进一个数组，如果数组中有哪个能和上表面相连，就输出Yes，反之，输出No。
代码
#include<bits/stdc++.h>
#define ll long long
using namespace std;
struct qwq
{
ll x;
ll y;
ll z;
};
bool cmp(qwq a,qwq b)
{
if(a.z!=b.z) return a.z<b.z;
if(a.x!=b.x) return a.x<b.x;
if(a.y!=b.y) return a.y<b.y;
}
ll dist(ll x1,ll y1,ll z1,ll x2,ll y2,ll z2)
{
return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2);
}
ll t,n,h,r,s,flag;
qwq tree[1010],g[1010];
int main()
{
cin>>t;
for(int c=1;c<=t;c++)
{
cin>>n>>h>>r;
s=0;
flag=0;
memset(tree,0,sizeof(tree));
for(int i=1;i<=n;i++) cin>>g[i].x>>g[i].y>>g[i].z;
sort(g+1,g+1+n,cmp);
for(int i=1;i<=n;i++)
{
flag=0;
if(g[i].z-r<=0)
{
s++;
tree[s].x=g[i].x;
tree[s].y=g[i].y;
tree[s].z=g[i].z;
}
for(int j=1;j<=s;j++)
if(dist(g[i].x,g[i].y,g[i].z,tree[j].x,tree[j].y,tree[j].z)<=4*r*r)
{
s++;
tree[s].x=g[i].x;
tree[s].y=g[i].y;
tree[s].z=g[i].z;
break;
}
if(tree[s].z+r>=h)
{
flag=1;
break;
}
}
if(flag) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
return 0;
}
P1119 灾后重建
题目背景
B 地区在地震过后，所有村庄都造成了一定的损毁，而这场地震却没对公路造成什么影响。但是在村庄重建好之前，所有与未重建完成的村庄的公路均无法通车。换句话说，只有连接着两个重建完成的村庄的公路才能通车，只能到达重建完成的村庄。
题目描述
给出 B 地区的村庄数
N
N
N，村庄编号从
0
0
0 到
N
−
1
N-1
N−1，和所有
M
M
M 条公路的长度，公路是双向的。并给出第
i
i
i 个村庄重建完成的时间
t
i
t_i
ti，你可以认为是同时开始重建并在第
t
i
t_i
ti 天重建完成，并且在当天即可通车。若
t
i
t_i
ti 为
0
0
0 则说明地震未对此地区造成损坏，一开始就可以通车。之后有
Q
Q
Q 个询问
(
x
,
y
,
t
)
(x,y,t)
(x,y,t)，对于每个询问你要回答在第
t
t
t 天，从村庄
x
x
x 到村庄
y
y
y 的最短路径长度为多少。如果无法找到从
x
x
x 村庄到
y
y
y 村庄的路径，经过若干个已重建完成的村庄，或者村庄
x
x
x 或村庄
y
y
y 在第
t
t
t 天仍未重建完成，则需要返回 -1。
输入格式
第一行包含两个正整数 N , M N,M N,M，表示了村庄的数目与公路的数量。
第二行包含 N N N个非负整数 t 0 , t 1 , … , t N − 1 t_0, t_1,…, t_{N-1} t0,t1,…,tN−1，表示了每个村庄重建完成的时间，数据保证了 t 0 ≤ t 1 ≤ … ≤ t N − 1 t_0 ≤ t_1 ≤ … ≤ t_{N-1} t0≤t1≤…≤tN−1。
接下来 M M M行，每行 3 3 3个非负整数 i , j , w i, j, w i,j,w， w w w为不超过 10000 10000 10000的正整数，表示了有一条连接村庄 i i i与村庄 j j j的道路，长度为 w w w，保证 i ≠ j i≠j i=j，且对于任意一对村庄只会存在一条道路。
接下来一行也就是 M + 3 M+3 M+3行包含一个正整数 Q Q Q，表示 Q Q Q个询问。
接下来 Q Q Q行，每行 3 3 3个非负整数 x , y , t x, y, t x,y,t，询问在第 t t t天，从村庄 x x x到村庄 y y y的最短路径长度为多少，数据保证了 t t t是不下降的。
输出格式
共 Q Q Q行，对每一个询问 ( x , y , t ) (x, y, t) (x,y,t)输出对应的答案，即在第 t t t天，从村庄 x x x到村庄 y y y的最短路径长度为多少。如果在第t天无法找到从 x x x村庄到 y y y村庄的路径，经过若干个已重建完成的村庄，或者村庄x或村庄 y y y在第 t t t天仍未修复完成，则输出 − 1 -1 −1。
样例 #1
样例输入 #1
4 5
1 2 3 4
0 2 1
2 3 1
3 1 2
2 1 4
0 3 5
4
2 0 2
0 1 2
0 1 3
0 1 4
样例输出 #1
-1
-1
5
4
提示
对于 30 % 30\% 30%的数据，有 N ≤ 50 N≤50 N≤50；
对于 30 % 30\% 30%的数据，有 t i = 0 t_i= 0 ti=0，其中有 20 % 20\% 20%的数据有 t i = 0 t_i = 0 ti=0且 N > 50 N>50 N>50；
对于 50 % 50\% 50%的数据，有 Q ≤ 100 Q≤100 Q≤100；
对于 100 % 100\% 100%的数据，有 N ≤ 200 N≤200 N≤200， M ≤ N × ( N − 1 ) / 2 M≤N \times (N-1)/2 M≤N×(N−1)/2， Q ≤ 50000 Q≤50000 Q≤50000，所有输入数据涉及整数均不超过 100000 100000 100000。
思路
floyd
代码
#include<bits/stdc++.h>
using namespace std;
const int MAXV=210,Q=50010;
int n,m,q,dis[MAXV][MAXV],t[MAXV],qu[Q],qv[Q],qt[Q];
int main()
{
cin>>n>>m;
for(int i=0;i<n;i++) cin>>t[i];
memset(dis,0x3f,sizeof(dis));
for(int i=1;i<=m;i++)
{
int u,v,w;
cin>>u>>v>>w;
dis[u][v]=dis[v][u]=w;
}
cin>>q;
for(int i=1;i<=q;i++) cin>>qu[i]>>qv[i]>>t[i];
int now=1;
t[n]=t[n-1]+1;
for(int k=0;k<n;k++)
{
while(now<=q&&qt[now]<t[k])
{
int qans=dis[qu[now]][qv[now]];
if(t[qu[now]]>=t[k]||t[qv[now]]>=t[k]) qans=-1;
printf("%d\n",qans==dis[n][n]?-1:qans);
now++;
}
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
dis[i][j]=min(dis[i][k]+dis[k][j],dis[i][j]);
}
while(now<=q)
{
int qans=dis[qu[now]][qv[now]];
printf("%d\n",qans==dis[n][n]?-1:qans);
now++;
}
return 0;
}
P2504 [HAOI2006]聪明的猴子
题目描述
在一个热带雨林中生存着一群猴子，它们以树上的果子为生。昨天下了一场大雨，现在雨过天晴，但整个雨林的地表还是被大水淹没着，部分植物的树冠露在水面上。猴子不会游泳，但跳跃能力比较强，它们仍然可以在露出水面的不同树冠上来回穿梭，以找到喜欢吃的果实。
现在，在这个地区露出水面的有N棵树，假设每棵树本身的直径都很小，可以忽略不计。我们在这块区域上建立直角坐标系，则每一棵树的位置由其所对应的坐标表示(任意两棵树的坐标都不相同)。
在这个地区住着的猴子有M个，下雨时，它们都躲到了茂密高大的树冠中，没有被大水冲走。由于各个猴子的年龄不同、身体素质不同，它们跳跃的能力不同。有的猴子跳跃的距离比较远(当然也可以跳到较近的树上)，而有些猴子跳跃的距离就比较近。这些猴子非常聪明，它们通过目测就可以准确地判断出自己能否跳到对面的树上。
【问题】现已知猴子的数量及每一个猴子的最大跳跃距离，还知道露出水面的每一棵树的坐标，你的任务是统计有多少个猴子可以在这个地区露出水面的所有树冠上觅食。
输入格式
输入文件monkey.in包括：
第1行为一个整数，表示猴子的个数M(2<=M<=500)；
第2行为M个整数，依次表示猴子的最大跳跃距离（每个整数值在1–1000之间）；
第3行为一个整数表示树的总棵数N(2<=N<=1000)；
第4行至第N+3行为N棵树的坐标（横纵坐标均为整数，范围为：-1000–1000）。
（同一行的整数间用空格分开）
输出格式
输出文件monkey.out包括一个整数，表示可以在这个地区的所有树冠上觅食的猴子数。
样例 #1
样例输入 #1
4
1 2 3 4
6
0 0
1 0
1 2
-1 -1
-2 0
2 2
样例输出 #1
3
提示
【数据规模】
对于40%的数据，保证有2<=N <=100，1<=M<=100
对于全部的数据，保证有2<=N <= 1000，1<=M=500
思路
kruskalkruskal算法，把所有边都连起来再跑最小生成树
代码
#include<bits/stdc++.h>
using namespace std;
struct Edge
{
int u,v;
double val;
}e[2000010];
int m,n,cnt,ans,num;
double maxans;
double a[510];
int x[1010],y[1010],fa[1010];
int find(int x)
{
if (fa[x]!=x) fa[x]=find(fa[x]);
return fa[x];
}
void unnion(int x,int y)
{
x=find(x);y=find(y);
if (x!=y) fa[x]=y;
}
bool judge(int x,int y)
{
x=find(x);y=find(y);
if (x==y) return 1;
else return 0;
}
void add(int u,int v,double w)
{
e[++cnt].u=u;e[cnt].v=v;e[cnt].val=w;
}
void kruskal()
{
int u,v;
for(int i=1;i<=cnt;i++)
{
u=e[i].u;v=e[i].v;
if (!judge(u,v)) maxans=e[i].val,num++,unnion(u,v);
if (num>n-1) break;
}
}
bool cmp(Edge a,Edge b)
{
return a.val<b.val;
}
int main()
{
cin>>m;
for(int i=1;i<=m;i++) cin>>a[i];
cin>>n;
for(int i=1;i<=n;i++) fa[i]=i;
for(int i=1;i<=n;i++) cin>>x[i]>>y[i];
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if (i!=j) add(i,j,sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])));
sort(e,e+cnt+1,cmp);
kruskal();
for(int i=1;i<=n;i++)
if (a[i]>=maxans) ans++;
cout<<ans<<endl;
return 0;
}
