4.2刷题记录

乘积最大

分类讨论错了，而且想的很麻烦，下次就是题目要求什么分析哪个变量

wa点：
1、因为temp1、temp2最大是10的10次方，不先处理（mod）的话会爆
2、比大小是不能去取模，9 % 8 == 1 ，7 % 8 == 7

ll a[maxn];

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    int n, k;
    cin >> n >> k;
    for (int i = 0; i < n; ++i){
        cin >> a[i];
    }
    if(n == k) {
        ll temp = 1;
        for (int i = 0; i < n; ++i){
            temp = ((temp % mod) * (a[i] % mod)) % mod;
        }
        cout << temp;
        return 0;
    }
    sort(a, a + n);
    ll temp;
    if(k % 2){
        temp = a[n - 1];
        int e = 1;
        if(temp < 0) e = -1;
        int l = 0, r = n - 2, cnt = 1;
        while(cnt != k) {
            ll temp1 = (a[l] * a[l + 1]), temp2 = (a[r] * a[r - 1]);
            if(temp1 * e > e * temp2){
                //temp = temp1 % mod * temp % mod;
                temp = (temp1 % mod) * (temp % mod) % mod;
                l += 2;
            }
            else {
                //temp = temp2 % mod * temp % mod;
                temp = (temp2 % mod) * (temp % mod) % mod;
                r -= 2;
            }
            cnt += 2;
            if(temp == 0)
                break;
        }
    }

密码脱落

前情提要： 最长公共子序列
了解
模板题

子串（马拉车， 连续）和子序列（不连续）是不一样的
对于回文： 添加多少个字母 = 删除多少个字母
∵中轴是一样的，左右两边字母对称，删去不对称的，那些删去的就是需要配对的
划分是找最后那个状态或者是边界上的那个不同点
当无法划分那个状态，但分析出来是正确的就找能覆盖那个状态的状态（包含）
对区间的循环方式： 见代码 + 先循环长度，再循环左右端点的其中一个

int dp[1005][1005];

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
	string s;
	cin >> s;
	int n = s.size();
	for (int len = 1; len <= n; ++len) {
		for (int j = 0; j + len - 1 < n; ++j) {
			int i = j + len - 1;
			if (len == 1)
				dp[j][i] = 1;
			else {
				if (s[j] == s[i])
					dp[j][i] = dp[j + 1][i - 1] + 2;
				dp[j][i] = max(max(dp[j + 1][i], dp[j][i - 1]), dp[j][i]);
			}

		}
	}
	cout << n - dp[0][n - 1];
	return 0;
}

后缀表达式

证明了加减号可以通过括号进行变换
树的前中后序遍历对应了前中后缀表达式
m = 0 加起来就是了
m > 0 要先减去min，再加上max，中间任意取都可以，不用考虑个数够不够，都说了可以互相转化

int a[maxn];

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    int n, m;
    cin >> n >> m;
    ll ans = 0;
    for (int i = 0; i < n + m + 1; ++i){
        cin >> a[i];
    }
    sort(a, a + n + m + 1);
    if(m == 0) {
        for(int i = 0; i < n + m + 1; ++i) ans += a[i];
    }
    else {
        ans -= a[0];
        ans += a[n + m];
        for(int i = 1; i < n + m; ++i){
            ans += abs(a[i]);
        }
    }
    cout << ans;
    return 0;
}

灵能传输

emmmm还是不会，直接贴答案吧
先得到前缀和，如果s[0]、s[n]可以换位置就没有下面这些推导了

起码学会了：
如果需要走两次同一个线段，那么就跳一个跳一个地走
还有如何遍历这个跳一个跳一个的线段
不开long long 见祖宗
这类的题，要么做不起，要么能找规律找规律，骗一点分是一点，基本是通过前缀和、差分、树之类的

ll a[maxn], s[maxn];
bool st[maxn];

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    int t;
    cin >> t;
    while(t--){
        int n;
        cin >> n;
        re(a);
        //re(s);
        s[0] = 0;
        
        for (int i = 1; i <= n; ++i){
            cin >> a[i];
            s[i] = s[i - 1] + a[i];
        }
        ll s0 = s[0], sn = s[n];
        sort(s, s + n + 1);
        if(s0 > sn))
            swap(s0, sn);
        for (int i = 0; i <= n; ++i){
            if(s0 == s[i]) {
                s0 = i;
                break;
            }
        }
        for (int i = n; i >= 0; --i){
            if(sn == s[i]) {
                sn = i;
                break;
            }
        }
        re(st);
         //构造重叠部分最小的序列
        int l = 0, r = n;
        for (int i = s0; i >= 0; i -= 2){
            a[l++] = s[i];
            st[i] = true;
        }
        for (int i = sn; i <= n; i += 2){
            a[r--] = s[i];
            st[i] = true;
        }
        for (int i = 0; i <= n; ++i){
            if(!st[i]) {
                a[l++] = s[i];
            }
        }
        ll res = 0;
         for (int i = 1; i <= n; ++i){
            res = max(res, abs(a[i] - a[i - 1]));
        }
        cout << res << endl;
    }
    return 0;
}