算法 {消除两两匹配}

算法 {消除两两匹配}

消除两两匹配

定义

{Ai}: i表示颜色, Ai表示颜色为i的小球个数;
. 操作1: 选择1个小球 将其消除; 操作2: 选择2个颜色不同的小球 将他俩消除;
问最小操作多少次, 可以消除全部小球;
. 比如{A1=4,A2=4,A3=3}, 答案为6, 方案为(A1,A3) (A2,A3) (A1,A2) (A1,A2) (A1,A2) (A3);

错误

看一个错误做法: 从大到小排序, 相邻的两个进行合并操作;
. 反例: {4,4,3}, 你的答案是4 + 3 = 7, 而正确答案是6;

@DELI;

[3,3,3], 此时需要变成[2,2] 是最优方案; 即当长度为3, 最小元素 要均分到那两个元素里;

算法

求最小操作次数

auto ___GetMinimalOperationCount = [&]( Int64_ _sum, Int64_ _max)->Int64_{
//< `_sum = sum({Ai}), _max = max({Ai})`;
    auto others = _sum - _max;
    decltype(_sum) doubles, singles;
    if( _max >= others){
        doubles = others; // `max`和`others`进行两两匹配;
        singles = _max - others; // 剩下的`max`单个处理;
    }
    else{
        doubles = _sum/2;
        singles = (_sum&1);
    }
    return doubles*C2 + singles*C1;
};

当max < others时, 为什么此时最多只有1个single呢? (直接证明比较麻烦, 这里通过构造法来证明, 参见下面的求方案);

求最小操作对应的方案

auto ___GetMinimalOperations = [&]( Int64_ _sum, Int64_ _max)->Int64_{
//< 令`A1<=A2<=...<=An` 则此时`An==_max`;
    auto others = _sum - _max;
    decltype(_sum) doubles, singles;
    if( _max >= others){
        doubles = others; // 用`An`和`A[<n]`进行两两匹配;
        singles = _max - others; // 剩下的`An`单个处理;
    }
    else{
        doubles = _sum/2;
        singles = (_sum&1);
        想象一个长度为`B[doubles*2]`的数组, 首先将`An`放到`B[偶数下标]`上(一定可以放下), 然后枚举`A1,A2...` 优先放到`[偶数下标]`上 否则就放到`[奇数下标]`上;
        比如答案可能是`[An,A1,An,A1,An,A2] 剩下一个单独的A2`, 答案也可能是`[An,A1,An,A2,A1,A2]`;
    }
    return doubles*C2 + singles*C1;
};

操作1|2有各自的代价, 求最小代价

@LINK: https://editor.csdn.net/md/?not_checkout=1&articleId=138498219;

例题

@LINK: https://editor.csdn.net/md/?not_checkout=1&articleId=137720531;
DP记录所有方案的价值和;

笔记

求方案

不保证正确…

auto ___GetMinimalGroups = [](){
//< 令`{An}`从小到大排序, `allCount = sum({Ai})`;
	ASSERT_SYSTEM_( n >= 1);
	auto others = _allCount - A[n];
	vector<pair<int,int> > ANS; // (i,i)表示自己单独;
	if( others <= A[n]){
		FOR_( i, 1, n-1){
			FOR_( c, 1, A[i]){ ANS.push( {i,n});}
		}
		while( ANS.size() < A[n]){ ANS.push( {n,n});}
		return ANS;;
	}
	
	int l = 1, r = n;
	while( r-l > 2){
		int mi = min(A[l], A[r]);
		FOR_( i, 1, mi){ ANS.push( {l,r});}
		A[l] -= mi;  A[r] -= mi;
		if( A[l] == 0){ ++ l;}
		if( A[r] == 0){ -- r;}
	}
	if( r-l == 2){ // `[3,3,2]` -> `[2,2]`
		找到`[l,l+1,r]`里面的最小元素`m`, 让m*平分的*和那两个进行匹配;
	}
	if( r-l == 1){
		两个匹配即可;
	}
	if( r-l == 0){
		自己一个;
	}
	
	return ANS;
};