2024ccpc长春邀请赛（vp补题）

D - Parallel Lines

题意：

有n个点，问能否找到k条平行线

思路：

每个点都一定属于一条平行线，第一个点来和所有的点遍历组合肯定可以找到一条线的平行关系是有k条的，只需要判断一下是否有k条
特判如果是垂直的，k等于无穷大，只要遍历每个点的x
注意：用double来存储k会爆精度，所以除法×分母转为整数型！！！！还有剪枝

代码实现：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int inf = 1e18;
const int N = 1e7 + 10;
const int mod = 1000000007;

void solve()
{
    int n, k;
    cin >> n >> k;

    vector<pair<int, int>>p(n + 1);

    for (int i = 1; i <= n; i++)
        cin >> p[i].first >> p[i].second;

    int x1 = p[1].first, y1 = p[1].second;
    int x2, y2;

    for (int i = 2; i <= n; i++)
    {
        x2 = p[i].first, y2 = p[i].second;
        
        int dx = x2 - x1;
        int dy = y2 - y1;

        map<int, vector<int>>q;
      
        for (int j = 1; j <= n; j++)
        {
            int x3 = p[j].first, y3 = p[j].second;
            //y=kx-b ydx=dyx-bdx 分数转化为整数
            int b = dx * y3 - dy * x3;
            q[b].push_back(j);

            if (q.size() > k)//剪枝！！！不加会t
                break;
        }

        if (q.size() == k)
        {
            int f = 1;
            for (auto x : q)
            {
                if (x.second.size() == 1)
                {
                    f = 0; break;
               }
            }

            if (f)
            {
                for (auto x : q)
                {
                    cout << x.second.size()<<" ";
                    for (auto xx : x.second)
                        cout << xx << " ";
                    cout << endl;
                }
                return;
            }
        }
    }
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int T = 1;
    //cin >> T;
    while (T--)
    {
        solve();
        // cout << endl;
    }
    return 0;
}

E - Connected Components

题意：

求满足式子的相连部分个数

思路：

式子可以推出 ai-i<=aj-j && i-bi<=j-bj
ai从小到大排序，已经满足第一个要求了 接下来看第二个要求，
如果当前值大则可以把前面的小值都纳入其中【和小的围成一个块】注意如果一个值大于这个块的最小值就可以入伙,
如果当前值小，则需要另开一个

代码实现：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int inf = 1e18;
const int N = 1e7 + 10;
const int mod = 1000000007;

void solve()
{
    int n;
    cin >> n;
    vector<pair<int, int>>q(n+1);
    for (int i = 1; i <= n; i++)
    {
        cin >> q[i].first >> q[i].second;
        q[i].first -= i;
        q[i].second = i - q[i].second;
    }

    sort(q.begin() + 1, q.end());

    vector<int>ans;//维护单调递减

    for (int i = 1; i <= n; i++)
    {
        if (ans.size()==0||q[i].second < ans.back())//若为空或者值小于最小，则另开一块
            ans.push_back(q[i].second);
        else if(q[i].second>ans.back())//若值大，则可以收纳块
        {
            int t = ans.back();//记录最小值
            while (ans.size()&&q[i].second >= ans.back())
                ans.pop_back();
            ans.push_back(t);//一个值大于这个块的最小值就可以入伙,所以更新的是最小值t
        }
    }
    cout << ans.size() << endl;
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int T = 1;
   // cin >> T;
    while (T--)
    {
        solve();
        // cout << endl;
    }
    return 0;
}

B - Dfs Order 0.5

题意：

dfs遍历时找的dfs序列，偶数位点值相加的最大值

思路：

一眼dp，找父亲和儿子的关系，经典的奇偶关系 ，依照题目设置状态，dp[u][0/1]以u为这个子树的dfs的第一个，且放在奇数/偶数位置时的最大值。

答案就是dp[1][0] 根节点1号结点放在第一个位置，所以是放在奇数位置时的最大值

关系转移：u的子树v1，v2，v3...可以分为偶子树和奇子树，表示子树的点有偶数个/奇数个 

1.全是偶子树，没有奇子树 ：那么u和v的关系就是 当u放在奇数位置，v放在整个序列偶位置的值就是v放在自己的奇位置的值之和

2.有奇子树存在：那么偶子树可以任意选择放在奇位置还是偶位置，奇子数分两类：1.奇子数有偶数个：半般放在奇数位置一半放在偶数位置；2.奇子数有奇数个：根据u的位置而改变

代码实现：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 100;
const int inf = 1e18;

int n;
vector<vector<int>>g(N);
vector<int>a(N);
vector<vector<int>>dp(N, vector<int>(4,0));
vector<int>sz(N,0);
//dp[u][0/1]包括u的子树，且u排在奇数/偶数位置时的子树和
//全是偶子树 u在奇数位置，v加上在偶数位置 
//若有奇子树 则偶子树可以任意排序，奇/偶位置都可以
//          则奇子树中可以选择一半作为0 一半作为1  --->全为偶 -偶+奇数
struct node
{
	int d, v0, v1;
	friend bool operator<(node a, node b)
	{
		return a.d < b.d;
	}
};

void dfs(int u, int fa)
{
	sz[u] = 1;
	dp[u][0] = 0, dp[u][1] = a[u];
	vector<int>odd;
	vector<int>even;//奇数，偶数

	for (auto v : g[u])
	{
		if (v == fa) continue;
		
		dfs(v, u);

		sz[u] += sz[v];

		if (sz[v] % 2)
			odd.push_back(v);
		else
			even.push_back(v);
	}
	if (odd.size() == 0)//全是偶数子树
	{
		for (auto v : even)
		{
			dp[u][1] += dp[v][0];
			dp[u][0] += dp[v][1];
		}
	}
	else//有奇数有偶数，偶数最优
	{
		for (auto v : even)
		{
			dp[u][1] += max(dp[v][0], dp[v][1]);
			dp[u][0] += max(dp[v][0], dp[v][1]);
		}
		//奇数一半一半
		int sum = 0;
		for (auto v : odd)//全放在偶数位置
		{
			sum += dp[v][1];
		}

		int p1 = (odd.size() + 1) / 2;//如果u放在偶数，则v有一半+1放在奇
		int p2 = odd.size() / 2;
		dp[u][1] += sum;
		dp[u][0] += sum;
		//求最优解，偶减奇数最小的优先
		sort(odd.begin(), odd.end(), [&](int x, int y)
			{
				return dp[x][1] - dp[x][0] < dp[y][1] - dp[y][0];
			});//内部排序

		for (int i = 0; i < p1; i++)
		{
			dp[u][1] = dp[u][1] + dp[odd[i]][0] - dp[odd[i]][1];
		}

		for (int i = 0; i < p2; i++)
		{
			dp[u][0] = dp[u][0] + dp[odd[i]][0] - dp[odd[i]][1];
		}
	}
}


void solve()
{
	cin >> n;

	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
		g[i].clear();
		sz[i] = 0;
	}

	for (int i = 1; i <= n - 1; i++)
	{
		int u, v;
		cin >> u >> v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	dfs(1, 0);
	cout << dp[1][0] << endl;
}

signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	int T = 1;
	cin>>T;
	while (T--)
	{
		solve();
		//cout<<endl;
	}
	return 0;
}