題解/算法 {6211. 创建价值相同的连通块}

oi-link

Solution

Let $sum$ be the sum of all values of points, assume we can divide this tree to $k$ partitions, then the $subsum$ of each partition equals to $sum/k$, this implies that $k|sum$

The range of $k$ is $[1,N]$ satisfying $k|sum$ simultaneously, so all valid values of $k$ is the factors of $sum$, and less than or equal to $N$. $O(sqrt(sum))=1000$.

Now, the question is, given a $k$, check if it is workable which is equivalent to whether would divide this tree to partitions with the same value $sum/k$ (emitting whether the number of partitions equals to $k$, due to it’s implied).

So, given a $subsum=sum/k$, if we can divide this tree to some partitions that with the same value of $subsum$.
Suppose these partitions are $T_1,T_2,...,T_k$, for a partition $T_i$, suppose $x$ is a point within it, this partition $T_i$ may contains some parent-nodes of $x$ partially, and also contains some son-nodes of $x$ partially.
On other words, $T_i$ may be not a simple-path, it may have several endpoints. So, $T_i$ can not be recorded when processing the DFS. This is the pivot for solving this problem.

The importance is, there must exists a $T_i$ that is a sub-tree, while a sub-tree can be recorded within a DFS (sub-tree is composed of one root-points and its all son-points).

Let the initial tree is $Tr$, when we get the $T_i$ (which is a sub-tree for $Tr$), then we remove it from $Tr$, then the new tree becomes $Tr1$, it has $k-1$ partitions.
This rule also effects in $Tr1$, that there also exists a $T_j$ that is a sub-tree for $Tr1$ (not for $Tr$).

The detail algorithm is, when we are doing DFS, for the current point $C$, get it value $s$ of this sub-tree (the value of $C$ plus all the DFS-return of its son-points), if equals to $subsum$, then remove this sub-tree, return $0$ to DFS-return; otherwise, it must connect to his parent, so return $s$.

Code

//{ Graph-Build
static constexpr int Graph_point_count_ = 20005, Graph_edge_count_ = 40005;
int Graph_head[ Graph_point_count_], Graph_ver[ Graph_edge_count_], Graph_nex[ Graph_edge_count_];
int Graph_edge_index;
inline void Graph_init(){
    memset( Graph_head, -1, sizeof( Graph_head));
    Graph_edge_index = 0;
}
inline void Graph_addEdge( int _from, int _to){
    // Graph_wth[ Graph_edge_index] = _wth;
    Graph_ver[ Graph_edge_index] = _to;
    Graph_nex[ Graph_edge_index] = Graph_head[ _from];
    Graph_head[ _from] = Graph_edge_index ++;
}
//} Graph-Build
class Solution {
public:
    vector< int> A;
    int Sub;
    int Dfs( int _cur, int _fa){
        int sum = A[ _cur];
        for( int j, i = Graph_head[ _cur]; ~i; i = Graph_nex[ i]){
            j = Graph_ver[ i];
            if( j == _fa){ continue;}
            sum += Dfs( j, _cur);
        }
        if( sum == Sub){ return 0;}
        return sum;
    }
    bool Check( int _s){
        Sub = _s;
        return Dfs( 0, -1) == 0;
    }
    int componentValue(vector<int>& AA, vector<vector<int>>& E) {
        A = AA;
        Graph_init( );
        for( auto & i : E){
            Graph_addEdge( i[0], i[1]);
            Graph_addEdge( i[1], i[0]);
        }
        int ma = *max_element( A.begin(), A.end());
        int sum = accumulate( A.begin(), A.end(), 0);
        int ans = 0;
        for( int cont = min( int( A.size()), sum / ma); ; --cont){
            if( sum % cont == 0){
                if( Check( sum / cont)){
                    return cont - 1;
                }
            }
        }
        assert( 0);
        return 0;
    }
};