2020牛客暑期多校训练营（第二场）DFCB补题报告

本篇仅用来监督自己补题

D：模拟，给你两个时刻，取两个时刻之间相差多少秒。

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int a,b,c;
	int x,y,z;
	char t;
	cin >> a >> t >> b >> t >> c;
	cin >> x >> t >> y >> t >> z;
	int t1 = a*3600+b*60+c;
	int t2 = x*3600 + y*60 + z;
	int ans = abs(t1 - t2);
	cout << ans << endl;
	return 0;
}

—————————————————————————————————————————————
滚回来补题了！！！

F：给你一个n*m的矩阵，矩阵A[i][j] = lcm(i,j). 再给你一个整数K，求所有k * k子矩阵中最大值的和。

直接暴力肯定会超时，但是还是可以O（nm）把矩阵打表
之后采用二维单调队列进行维护。

定义矩阵ans[i][j]，记录以（i，j）为右下角kk窗口内的最大元素。
首先针对所有行进行单调队列维护。
此时，ans数组表示的是第i行截止到j的k个连续元素的最大值
之后，再对所有列进行单调队列维护
注意：对列进行单调维护时使用的是ans数组
这样，ans的意义就从每行以j为终点，长度为k的窗口的最大值 变成了 以（i，j）为右下角的KK窗口的最大值

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 5050;
int a[maxn][maxn];
int gcd(int a,int b)
{
    return b == 0 ? a : gcd(b, a % b);
}
int n,m,k;
int que[maxn] = {0};
int ans[maxn][maxn] = {0}; 
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            a[i][j] = i / gcd(i,j) * j;
        }
    }
    //直接O(nm)打表求矩阵
	//接下来是二维单调队列
	for(int i = 1; i <= n; i++)
	{//对每一行都进行单调队列 
		int head = 1, tail = 1;
		que[1] = 1;//队列中存储的是元素在a数组中的下表 
		for(int j = 1; j <= m; j++)
		{
			while(head != tail && a[i][j] >= a[i][que[tail-1]]) tail--;
			//先要添加新的元素，从队尾向队首遍历，把小的都直接踢出队
			que[tail++] = j;//把新元素加入队中，放在队尾
			while(head != tail && j - que[head] + 1 > k) head++;
			//维护队首，随着窗口的移动，队首也要移动
			ans[i][j] = a[i][que[head]];//记录最大的 
		} 
	}
	//对每一行进行单调队列维护，得到窗口内最大的元素 
	for(int i = 1; i <= m; i++)
	{
        int head = 1, tail = 1;
		que[1] = 1;
        for(int j = 1; j <= n; j++)
		{
            while(head != tail && ans[j][i] >= ans[que[tail-1]][i]) tail--;
            que[tail++] = j;
			while(head <= tail && j - que[head] + 1 > k) head++;
            ans[j][i] = ans[que[head]][i];
        }
    }
    //再对每一列进行单调队列维护，得到k*k窗口内最大的元素
	long long sum = 0;
	for(int i = k; i <= n; i++)
	{
		for(int j = k; j <= m; j++)
		{
			sum += ans[i][j];
		}
	 }
	 cout << sum << endl; 
    return 0;
}

---

我又回来更新了

C：给你一颗n个点组成的无根树，问：最少使用多少条链，可以覆盖这棵树所有的边（可以重复覆盖）

一开始写题时想到了需要将叶子节点相连，但是如何保证覆盖所有边没有想到。

首先特判n = 2，那么只需要把给的一条边相连就可以了。
之后，选择一个度数大于1的点当做根节点，从根节点开始进行dfs，记录所有的叶子节点
假设一共有num个叶子节点，那么，最少需要（n+1） / 2条链来进行覆盖。
如果num为偶数，叶子节点可以组成n/2对，如果是奇数，组成n/2对，最后落单的一个要和根节点相连
叶子节点的配对为 编号为i的叶子节点 与 编号为i+（num+1）/2的叶子节点。
算法分析：
看到题解之后，我就不明白，为什么是i和i+（num+1）/2两个叶子配对呢？

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 2e5 + 50;
vector<int> map[maxn];
int num = 0,root;
int a[maxn];
void dfs(int x, int fa)
{
	if(map[x].size() == 1)
	{//记录叶子节点 
		a[++num] = x;
		return ;
	}
	for(int i = 0; i < map[x].size(); i++)
	{//继续dfs 
		int now = map[x][i];
		if(now == fa) continue;
		dfs(now,x);
	}
}
int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int n;
	cin >> n;
	int u,v;
	for(int i = 1; i <= n - 1; i++)
	{
		cin >> u >> v;
		map[u].push_back(v);
		map[v].push_back(u);
		if(map[u].size() > 1) root = u;
		if(map[v].size() > 1) root = v;
	}
	if(n == 2)
	{
		cout << 1 << endl;
		cout << u << " " << v << endl;
		return 0;
	}
	dfs(root,-1);
	cout << (num+1)/2 << endl;
	for(int i = 1; i <= num / 2; i++)
	{
		cout << a[i] << " " << a[i+(num+1)/2] << endl;
	}
	if(num % 2 == 1)
	{
		cout << root << " " << a[(num/2) + 1] << endl;
	}
	return 0;
}

————————————————————————————————————————————
又回来补B题了

B：给你n个点，请确定一个圆，保证原点（0,0）在圆上，同时已知n个点在圆上的数目最多，输出最多的数目。

数据量为e3，可以n方。利用三点确定圆，已知原点，再n方确定圆心，用map计数即可。
偷来的三点确定圆模板，一定补上模板算法解释。

已知原点，第一重循环为循环定点P，二重循环里是第三个点Q。三点得到一个圆，map的值记录的是已知原点与P点，之后同圆的点数目。
map在更换P点时要清空，避免一个点被重复计数。
最后的ans需要加1，加上P点自己。

#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
using namespace std;
const int maxn = 2e3 + 50;
const double eps = 1e-5;
int n;
struct node
{
	double x,y;
}a[maxn]; 
map<pair<double,double>,int> m;
int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	
	cin >> n;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i].x >> a[i].y;
	}
	int ans = 0;
	for(int i = 1; i <= n; i++)
	{
		m.clear();
		//为了避免点重复计算
		for(int j = i+1; j <= n; j++)
		{
			double x1,x2,x3;
			double y1,y2,y3;
			x1 = a[i].x;
			x2 = a[j].x;
			x3 = 0;
			y1 = a[i].y;
			y2 = a[j].y;
			y3 = 0;
			
			double a = x1 - x2;
    		double b = y1 - y2;
    		double c = x1 - x3;
    		double d = y1 - y3;
    		double e = ((x1 * x1 - x2 * x2) + (y1 * y1 - y2 * y2)) / 2.0;
    		double f = ((x1 * x1 - x3 * x3) + (y1 * y1 - y3 * y3)) / 2.0;
    		double det = b * c - a * d;
    		if (fabs(det) < eps)  //三点共线
        	continue;
    		double x = -(d * e - b * f) / det;
    		double y = -(a * f - c * e) / det;
			pair<double,double> center = {x,y};
			ans = max(ans,++m[center]);
		}
	}
	cout << ans+1 << endl;
	return 0;
}