力扣2月最后三天的每日一题

---

前言

不会做，全靠灵神的视频讲解

2867.统计树中的合法路径数目

思路

考虑质数节点，每个质数节点应该都有属于它自己的多个连通块，而每个连通块中存在的非质数路径那么就可以形成一条合法路径

所以我们需要去统计一个质数的连通块中有多少非质数的连通情况，最后结果相加即可

确定1e5中的质数

对于一个质数，其的倍数一定不是质数

    void checknp(bool* np)
    {
        np[1] = true;
        for(int i = 2;i*i<MX+1;i++)
        {
            for(j = i*i ;j <MX+1;j+=i)
            {
                if(!np[i])
                {
                    np[j] = true;
                }
            }
        }
    }

统计每个点的连接情况

根据传入参数edgs数组，可以得到每个点与哪些点连接

        vector<vector<int>> connect(n+1);
        for(auto edge : edges)
        {
            connect[edge[0]].push_back(edge[1]);
            connect[edge[1]].push_back(edge[0]);
        }

开始对质数点进行处理

我们需要用到记忆化搜索的技巧。当我们对一个非质数与哪些非质数连接情况进行讨论后，我们可以将结果存储，如果后面有质数节点也与该非质数节点连接，那么就可以直接使用了。

//记录返回值 和 记忆化存储非质数节点与多少个非质数节点连接
long long res = 0;
vector<int> mem(n+1);
for(int i = 1;i<n+1;i++)
{
	//如果是非质数，就可以跳过，因为我们只考虑质数的连通
	if(np[i]) continue;
	//记录连通数
	int sum = 0;
	//对i的连通点进行处理结果
	for(int j : connect[i])
	{
		//只考虑非质数的情况
		if(!np[j]) continue;
		//如果没有被搜索过
		if(mem[j] == 0)
		{
			//存储相互连接节点的数组清空
			nodes.clear();
			checknodes(j,-1,connect);
			//对于nodes数组里面的所有点，其连通点的个数都是nodes数组的长度
			for(int k : nodes)
			{
				mem[k] = nodes.size();
			}
		}
		//计算结果，质数i下面的j连通块
		res += mem[j] * sum;
		sum += mem[j];
	}
	//以质数为头的结果
	res += sum;
}

完整代码

const int MX = 1e5;
class Solution {
private:
    bool np[MX+1];
    vector<int> nodes;
public:
    void checknp(bool* np)
    {
        np[1] = true;
        for(int i = 2;i*i<MX+1;i++)
        {
            for(int j = i*i ;j <MX+1;j+=i)
            {
                if(!np[i])
                {
                    np[j] = true;
                }
            }
        }
    }

    void checknodes(int x,int fa,vector<vector<int>>& connect)
    {
        nodes.push_back(x);
        for(int y:connect[x])
        {
            if(y!=fa&&np[y])
            {
                checknodes(y,x,connect);
            }
        }
    }
public:
    long long countPaths(int n, vector<vector<int>>& edges) {
        checknp(np);
        vector<vector<int>> connect(n+1);
        for(auto edge : edges)
        {
            connect[edge[0]].push_back(edge[1]);
            connect[edge[1]].push_back(edge[0]);
        }
        //结果
        long long res = 0;
        //记忆化搜索
        vector<int> mem(n+1);
        for(int i = 1;i<n+1;i++)
        {
            if(np[i]) continue;
            //记录当前节点的连接数
            int sum = 0;
            for(int j : connect[i])
            {
                if(!np[j]) continue;
                //如果没被遍历过
                if(mem[j] == 0)
                {
                    nodes.clear();
                    checknodes(j,-1,connect);
                    //修改记忆存储结果
                    for(int k : nodes)
                    {
                        mem[k] = nodes.size();
                    }
                }
                //统计该连通块对结果的影响
                res += mem[j]*sum;
                sum += mem[j];
            }
            //已质数节点为头的情况
            res += sum;
        }
        return res;
    }
};

2673.使二叉树所有路径值相等的最小代价

思路

从叶子节点开始，计算根节点到该叶子节点的路径和，然后修改其中一个叶子节点使得和相等，由于只能增加，所以向大值修改。
修改完成后将该和返回给叶子节点的父节点，然后比较同一层级的父节点的和，进行修改。
逐步返回直到根节点

完整代码

对于满二叉树，父节点和左右子结点在数组中存在一个关系。

class Solution {
public:
    int minIncrements(int n, vector<int>& cost) {
        //统计每个节点的路径和
        for(int i = 2;i<n+1;i++)
        {
            cost[i-1] += cost[i/2-1];
        }
        //更新结果
        int res = 0;
        for(int i = n/2;i>0;i--)
        {
            res += abs(cost[2*i]-cost[2*i-1]);
            cost[i-1] = max(cost[2*i],cost[2*i-1]);
        }
        return res;
    }
};

2581.统计可能的树根数目

思路

还不是很明白
我们假设以0为根的正确猜测是cnt0，那调换到以1为根，那么cnt1的值
首先需要减去guesses数组[0,1]的数量，再加上[1,0]的数量，因为[u,v]表示u是v的父节点。
其余调换类似。

建立连通关系

vector<vector<int>> g(edges.size() + 1);
for (auto &e : edges) 
{
	int x = e[0], y = e[1];
	g[x].push_back(y);
	g[y].push_back(x);
}

将猜测数组变为哈希表，方便查询

unordered_set<LL> s;
for (auto &e : guesses) 
{ // guesses 转成哈希表
	s.insert((LL) e[0] << 32 | e[1]); // 两个 4 字节数压缩成一个 8 字节数
}

利用dfs初始化根为0的猜测正确数量

int ans = 0, cnt0 = 0;
function<void(int, int)> dfs = [&](int x, int fa) 
{
	//y与x连通
	for (int y : g[x])
	{
		//y不是父节点，防止反向计算
		if (y != fa) 
		{
			//[x,y]如果存在哈希表中，表面以0为根的结果猜测正确+1
			cnt0 += s.count((LL) x << 32 | y); // 以 0 为根时，猜对了
			//以当前节点为父节点搜索子结点
			dfs(y, x);
		}
	}
};
dfs(0, -1);

统计完整的结果

//计算以x为根的cnt
function<void(int, int, int)> reroot = [&](int x, int fa, int cnt) 
{
	ans += cnt >= k; // 此时 cnt 就是以 x 为根时的猜对次数
	for (int y : g[x]) 
	{
		if (y != fa) 
		{
		//从0开始，变换根为0的连通节点，在变换为连通节点的连通节点
			reroot(y, x, cnt
			- s.count((LL) x << 32 | y)   // 原来是对的，现在错了
			+ s.count((LL) y << 32 | x)); // 原来是错的，现在对了
		}
	}
};
reroot(0, -1, cnt0);