U567760 序列和 题解

题解

传送门

20pts

暴力 dfs，判断是否是严格上升子序列，最后求最大值。
dfs 过程中可以记录上一项以及当前的序列和，方便剪枝和求和。
时间复杂度 $O(2^n)$。

Code

#include <bits/stdc++.h>
#define int long long
using namespace std;
inline int read()
{
	int x = 0,p = 1;
	char c = getchar();
	while(c > '9' || c < '0')	p = c == '-' ? -1 : 1,c = getchar();
	while(c >= '0' && c <= '9')	x = (x << 1) + (x << 3) + (c ^ 48),c = getchar();
	return p * x;
}
template<typename _Tp> inline void _write(_Tp x) { if(x > 9) _write(x / 10); putchar(x % 10 | 48); }
template<typename _Tp> inline void write(_Tp x) { if(x < 0) putchar('-'),x = -x; _write(x); }
template<typename _Tp> inline void writeln(_Tp x) { write(x); puts(""); }
const int N = 1e5 + 10;
int n,a[N],ans = 0;
void dfs(int step,int last = 0,int sum = 0)
{
    if(step == n + 1)
    {
        ans = max(ans,sum);
        return;
    }
    dfs(step + 1,last,sum);
    if(a[step] > last)  dfs(step + 1,a[step],sum + a[step]);
}
signed main()
{
	n = read();
	for(int i = 1;i <= n;i++)	a[i] = read();
    dfs(1);
    writeln(ans);
	return 0;
}

40pts

考虑 dp。设 $f_i$ 为最后一项是 $a_i$ 时的最优情况。
可以得到状态转移方程：$f_i={\max }_{j=1}^{i-1}{f}_j\times [a_j<a_i]+a_i$。
其中当 $a_j<a_i$时 $[a_j<a_i]$ 为 $1$，否则值为 $0$。
最初 $f_1=a_1$，最终答案为 ${\max }_{i=1}^n{f}_i$。
时间复杂度 $O(n^2)$。

Code

#include <bits/stdc++.h>
#define int long long
using namespace std;
inline int read()
{
	int x = 0,p = 1;
	char c = getchar();
	while(c > '9' || c < '0')	p = c == '-' ? -1 : 1,c = getchar();
	while(c >= '0' && c <= '9')	x = (x << 1) + (x << 3) + (c ^ 48),c = getchar();
	return p * x;
}
template<typename _Tp> inline void _write(_Tp x) { if(x > 9) _write(x / 10); putchar(x % 10 | 48); }
template<typename _Tp> inline void write(_Tp x) { if(x < 0) putchar('-'),x = -x; _write(x); }
template<typename _Tp> inline void writeln(_Tp x) { write(x); puts(""); }
const int N = 1e5 + 10;
int n,a[N],f[N];
signed main()
{
	n = read();
	for(int i = 1;i <= n;i++)	a[i] = read();
    f[1] = a[1];
    for(int i = 2;i <= n;i++)
        for(int j = 1;j < i;j++)
            if(a[j] < a[i])
                f[i] = max(f[i],f[j] + a[i]);
    writeln(*max_element(f + 1,f + n + 1));
	return 0;
}

70pts

换一种 dp 方式，设 $f_{i,j}$ 为在前 $i$ 个数中，以 $j$ 结尾的子序列的最值，其中 $j\le 10^3$。
所以 $f_{i,j}={\max }_{k=1}^{i-1}{\max }_{l=1}^{j-1}{f}_{k,l}+a_i$。
答案为 ${\max }_{i=1}^n{\max }_{j=1}^m{f}_{i,j}$。
暴力 dp 时间复杂度为 $O(mn)$，其中 $m$ 为 $a_i$ 的值域。但是此时空间复杂度太高，于是需要降维。

降维后可以发现转移方程变为 $f_j={\max }_{k=1}^{j-1}{f}_k+j$。
其中求 ${\max }_{k=1}^{j-1}$ 时可以使用树状数组将时间复杂度降至 $O(\log m)$，空间复杂度 $O(m)$。
总时间复杂度 $O(n\log m)$。

Code

#include <bits/stdc++.h>
#define int long long
using namespace std;
int read()
{
	int x = 0,p = 1;
	char c = getchar();
	while(c > '9' || c < '0')	p = c == '-' ? -1 : 1,c = getchar();
	while(c >= '0' && c <= '9')	x = (x << 1) + (x << 3) + (c ^ 48),c = getchar();
	return p * x;
}
void _write(int x) { if(x > 9) _write(x / 10); putchar(x % 10 | 48); }
void write(int x) { if(x < 0) putchar('-'),x = -x; _write(x); }
void writeln(int x) { write(x); puts(""); }
const int N = 1e5 + 10;
int n,a[N];
int bit[1010];
struct BIT
{
    int N;
    BIT() : N(1000) {}
	int f(int x) { return x & -x; }
	void add(int x,int k)
	{
		while(x <= N)
		{
			bit[x] = max(bit[x],k);
			x += f(x);
		}
	}
	int _max(int n)
	{
		int res = 0;
		while(n >= 1)
		{
			res = max(res,bit[n]);
			n -= f(n);
		}
		return res;
	}
};
signed main()
{
	n = read();
	for(int i = 1;i <= n;i++)	a[i] = read();
	BIT _bit;
	for(int i = 1;i <= n;i++)
	{
		_bit.add(a[i],a[i] + _bit._max(a[i] - 1));
	}
	cout << _bit._max(1000) << endl; 
	return 0;
}

100pts

在 70pts 的基础上进行离散化。
时间复杂度 $O(n\log n)$。
空间复杂度 $O(n)$。

AC Code

#include <bits/stdc++.h>
#define int long long
using namespace std;
int read()
{
	int x = 0,p = 1;
	char c = getchar();
	while(c > '9' || c < '0')	p = c == '-' ? -1 : 1,c = getchar();
	while(c >= '0' && c <= '9')	x = (x << 1) + (x << 3) + (c ^ 48),c = getchar();
	return p * x;
}
void _write(int x) { if(x > 9) _write(x / 10); putchar(x % 10 | 48); }
void write(int x) { if(x < 0) putchar('-'),x = -x; _write(x); }
void writeln(int x) { write(x); puts(""); }
const int N = 1e5 + 10;
int n,a[N],b[N];
map<int,int> rk;
int bit[N];
struct BIT
{
	int f(int x) { return x & -x; }
	void add(int x,int k)
	{
		while(x <= n)
		{
			bit[x] = max(bit[x],k);
			x += f(x);
		}
	}
	int _max(int n)
	{
		int res = 0;
		while(n >= 1)
		{
			res = max(res,bit[n]);
			n -= f(n);
		}
		return res;
	}
};
signed main()
{
	n = read();
	for(int i = 1;i <= n;i++)	b[i] = a[i] = read();
	sort(b + 1,b + n + 1);
	for(int i = 1;i <= n;i++)	rk[b[i]] = i;
	BIT _bit;
	for(int i = 1;i <= n;i++)
	{
		_bit.add(rk[a[i]],a[i] + _bit._max(rk[a[i]] - 1));
	}
	cout << _bit._max(n) << endl; 
	return 0;
}