CH Round #49 - Streaming #4 (NOIP模拟赛Day2) 解题报告

题目来源：CH Round #49 - Streaming #4 (NOIP模拟赛Day2) 

Part.1 二叉树的根（root）

暴力无脑，直接判断：

存在度数大于3的点——无解；

否则，所有度数为1或2的点都是解。

参考代码

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdio>
using namespace std;
int size[100005],b[100005];
int main()
{
	int n,x,y,cnt=0;
	scanf("%d",&n);
	for (int i=1;i<n;i++)
	{
		scanf("%d%d",&x,&y);
		size[x]++;
		size[y]++;
	}
	for (int i=1;i<=n;i++)
	{
		if (size[i]>3) 
		{
			cout<<0;
			return 0;
		}
		else
		{
			if (size[i]<=2)
			{
				cnt++;
				b[cnt]=i;
			}
		}
	}
	printf("%d\n",cnt);
	for (int i=1;i<=cnt;i++)
		printf("%d%c",b[i],' ');
	return 0;
}

Part.2 距离统计（dist）

正解主要靠数论，然而水平不够，看不懂TAT。。。所以只拿了部分分。

40分算法：

1.   对于每次询问暴力枚举所求线段在x方向和y方向的投影，统计出这种平行线段的个数，时间复杂度O(Tn²)。（官方搞法）

2.  本人的搞法：提前预处理出所有i<=2n、j<=2m范围内组成的勾股数k（i²+j²=k²），暴力跑，然后排序，40%不会超时，再往上就呵呵了。（本质和第一种方法差不多，可能没有那一种优。。。）然后对每次询问进行如下操作：

①  判断l是否合法：如果l超过点阵对角线的长度，无解，输出0；

②  判断是否能横放、竖放：

横：ans+=(n-l)*m;   竖：ans+=(m-l)*n;

③  判断能否放对角线：

暴力从第一个勾股数开始找（应该有不用从头跑的优化方法，然而就题目本身而言没啥用），直到碰到比l²大的数就退出，这期间如果有与l2相等的勾股数，进行如下操作（自己画画图就明白了）：

sx=a[j].x;  sy=a[j].y; //分解出来的的i和j

if(n-sx>0&&m-sy>0) ans+=(n-sx)*(m-sy)*2;

if(n-sy>0&&m-sx>0) ans+=(n-sy)*(m-sx)*2;

60分算法：

本质上我们是在解方程a²+b²=l²，只需要枚举a，检验b²是否是完全平方数即可，时间复杂度O(Tn)。

Ps.Long long 大法好。

100分算法：

（神奇的数论。。。）

参考官方题解

 40%代码

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdio>
using namespace std;
long long ans=0;
struct mc
{
	int x,y;
	long long ans;
	bool operator<(const mc b) const
	{
		return ans<b.ans;
	}
}a[1000086];

int main()
{
	long long n,m,t;
	scanf("%lld%lld%lld",&n,&m,&t);
	long long max=sqrt((n-1)*(n-1)+(m-1)*(m-1));
	if (n>m) swap(n,m);
	long long ans=0,cnt=0;
	for (int i=1;i<=n;i++)
	for (int j=i;j<=m;j++)
	{
		ans=(long long)(i*i+j*j);
		if (sqrt(ans)*sqrt(ans)==ans)
		{
			cnt++;
			a[cnt].ans=ans;
			a[cnt].x=i;
			a[cnt].y=j;
		}
	}
	sort(a+1,a+cnt+1);
	long long l;
	int sx,sy;
	for (int i=1;i<=t;i++)
	{
		scanf("%lld",&l);
		ans=0;
                if (l>max)
		{
			cout<<0<<' ';
			continue;
		}
		if (l<=n-1) ans+=(n-l)*m;
		if (l<=m-1) ans+=(m-l)*n;
		bool ff=0;
		for (int j=1;j<=cnt;j++)
		{
			if (a[j].ans==l*l)
			{
				ff=1;
				sx=a[j].x;
				sy=a[j].y;
				if (n-sx>0&&m-sy>0) ans+=(n-sx)*(m-sy)*2;
		        if (n-sy>0&&m-sx>0) ans+=(n-sy)*(m-sx)*2;
			}
			if (a[j].ans>l*l)
			break;
		}
		printf("%lld%c",ans,' ');
    }
    return 0;
}

60%参考代码

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdio>
#define ll long long
using namespace std;
long long ans=0;

int main()
{
	ios::sync_with_stdio(false);
	int n,m,t;
        long long k1=(ll)(n-1)*(ll)(n-1),k2=(ll)(m-1)*(ll)(m-1);
	long long max=(ll)sqrt(k1+k2);
	long long l;
	long long sx,sy;
	for (int i=1;i<=t;i++)
	{
		cin>>l;
		ans=0;
		if (l>max)
		{
			cout<<0<<' ';
			continue;
		}
		if (l<=(ll)(n-1)) ans+=(ll)(n-l)*m;
		if (l<=(ll)(m-1)) ans+=(ll)(m-l)*n;
		for (int j=1;j<n;j++)
		{
			sx=(ll)j;
			sy=(ll)(l*l-sx*sx);
			if ((ll)sqrt(sy)<sx) break;
			if ((ll)sqrt(sy)*sqrt(sy)==sy&&sy>0)
			{
				sy=(ll)sqrt(sy);
				if (n-sx>0&&m-sy>0) ans+=(ll)(n-sx)*(m-sy)*2;
		                ans+=(ll)(n-sy)*(m-sx)*2;
			}
		}
	}
    return 0;
}

100%代码（官方）

#include <cstdio>
#include <cstring>
#include <cmath>
#define f(x, y, z) for(int x = (y); x <= (z); ++x)
#define ll long long

bool prime[50008];
int pn = 0, p[50008], n, m, T, l, x[12], a[12], xn;
ll ans = 0;

inline int gcd(int x, int y){
	while(y){
		int t = x % y; x = y; y = t;
	}
	return x;
}

inline void calc(int l){
	xn = 0;
	f(i, 1, pn){
		if(p[i] * p[i] > l) break;
		if(l % p[i] == 0){
			x[++xn] = p[i]; a[xn] = 0;
			while(l % p[i] == 0){
				l /= p[i]; ++a[xn];
			}
		}
	}
	if(l > 1){
		x[++xn] = l; a[xn] = 1;
	}
}

inline void add(int a, int b){
	if(n > a && m > b) ans += (ll) (n - a) * (ll) (m - b) * 2LL;
	if(m > a && n > b) ans += (ll) (m - a) * (ll) (n - b) * 2LL;
}

inline void check(int x){
	f(c, 1, x){
		int b = x - c * c;
		if(b <= 0) break;
		ll req = (ll) x * (ll) x - (ll) b * (ll) b;
		double ar = sqrt(req);
		if(ar >= b) break;
		int a = ar + 0.5;
		if((ll) a * (ll) a == req && gcd(x, gcd(a, b)) == 1) add(a * (l / x), b * (l / x));
	}
	f(c, 1, x){
		int b = x - c * c * 2;
		if(b <= 0) break;
		ll req = (ll) x * (ll) x - (ll) b * (ll) b;
		double ar = sqrt(req);
		if(ar >= b) break;
		int a = ar + 0.5;
		if((ll) a * (ll) a == req && gcd(x, gcd(a, b)) == 1) add(a * (l / x), b * (l / x));
	}
}

inline void dfs(int p, int c){
	if(p > xn) check(c);
	else f(i, 0, a[p]){
		dfs(p + 1, c); c *= x[p]; 
	}
}

int main(){
	memset(prime, 1, sizeof(prime));
	f(i, 2, 50000) if(prime[i]){
		p[++pn] = i;
		for(int j = i * 2; j <= 50000; j += i) prime[j] = 0;
	}
	scanf("%d%d%d", &n, &m, &T);
	while(T--){
		scanf("%d", &l); calc(l);
		ans = 0;
		if(m > l) ans += (ll) n * (ll) (m - l);
		if(n > l) ans += (ll) (n - l) * (ll) m;
		dfs(1, 1);
		printf("%I64d ", ans);
	}
	return 0;
}

Part.3 电阻网络（resi）

搜索，巧妙的大搜索。。。这道题能否愉快地A掉，一定程度上取决于审题，如果能从题目中提炼出有效&&关键信息，那么就基本可以找到搜索的正确方向了。

Point.1 三个元件

具体地，假设所有边都是从左到右的，那么接点（除了整个电路的负极以外）可以分成3类（提取自下图原文）：

①  出度为2的——并联电路的开始；

②  出度为1&&出边边权为0的——并联电路的结束；

③出度为1&&出边边权为1的——是一个电阻。

然后就可以从1开始搜索了。

Point.2 电阻计算

①  串联电阻：直接+1；

②并联电阻：捆绑看作一个电阻，先处理这一部分的总电阻。

参考代码（附加说明）：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdio>
using namespace std;
int mix,n;
struct mc
{
	int size;
	int po[2];
	bool resi;
}e[100005];

void put(int x,int y,int l)
{
	e[x].size++;
	e[x].po[e[x].size]=y;  //两个||一个出边指向的接点；
	if (l==1) e[x].resi=true;  //point.3 ③
}

float search(int x)
{
	if (x==n) return 0;  //搜索结束；
	if (e[x].resi)  //单个电阻，直接加；
		return search(e[x].po[1])+1;
	else
	{
		if (e[x].size>1)
		{
			float t1=0,t2=0,num;
			int p1=e[x].po[1],p2=e[x].po[2];
			t1=search(p1);
			t2=search(p2);
			num=(t1*t2)/(t1+t2);  //并联电路；
			num+=search(mix);  //并联电路之后的部分；
		}else  
		{
			mix=e[x].po[1];  //mix表示并联电路结束的接点；
			return 0;
		}
	}
}

int main()
{
	int m,x,y,z;
	scanf("%d%d",&n,&m);
	for (int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&x,&y,&z);
		put(x,y,z);
	}
	int t;
	float resi=search(1);
	printf("%.3lf",resi);
	return 0;
}