Problem A
分两种情况：
- 本身就不在内：直接输出d
- 否则，输出第一个大于r的d的倍数。也就是
d * (r / d + 1)
时间复杂度为
#include
using namespace std;
typedef long long LL;
int main()
{
int q;
scanf("%d", &q);
while(q--)
{
LL l, r, d;
scanf("%lld%lld%lld", &l, &r, &d);
if((d < l) || (d > r))
{
printf("%lld\n", d);
continue;
}
printf("%lld\n", d * (r / d + 1));
}
return 0;
}
Problem B
先去掉多余的字符。只保留[，]，:，|这四种字符。
然后找最靠左的[:（两个字符可以不用紧邻，下同）和最靠右的:]，然后再其中间找出所有的|，拼起来就是答案的字符串了。输出长度即可。
注意[:]的情况，这种情况是非法的。
时间复杂度为
#include
#include
using namespace std;
typedef long long LL;
bool CheckChr(char &c)
{
if(c == '[')return true;
if(c == ']')return true;
if(c == ':')return true;
if(c == '|')return true;
return false;
}
int FindL(string &s)
{
int pos = 0;
while(pos < s.length())
{
if(s[pos] == '[')break;
pos++;
}
while(pos < s.length())
{
if(s[pos] == ':')break;
pos++;
}
return pos;
}
int FindR(string &s)
{
int pos = s.length() - 1;
while(pos >= 0)
{
if(s[pos] == ']')break;
pos--;
}
while(pos >= 0)
{
if(s[pos] == ':')break;
pos--;
}
return pos;
}
int GetAns(string &s, int l, int r)
{
if(l >= r)return -1;
int ans = 4;
for(int i = l + 1; i < r; I++)
{
if(s[i] == '|')ans++;
}
return ans;
}
int main()
{
string s;
while(cin >> s)
{
string tmp;
for(int i = 0; i < s.length(); I++)
{
if(CheckChr(s[I]))
{
tmp += s[I];
}
}
s = tmp;
cout << GetAns(s, FindL(s), FindR(s)) << endl;
}
return 0;
}
Problem C
思路的出发点类似于区间覆盖的贪心算法。
首先，对区间按左值从小到大排序。
然后将第一个区间（也就是最左边的区间）放入集合1，从左往右遍历：
- 若当前区间与集合1相交，那么将其放入集合1中
- 否则说明从当前区间开始往右的区间都不会跟集合1相交，将包括当前区间在内的剩余区间置入集合2
于是我们就可以得到一种分割方法。
当然，如果这样扫一遍发现所有区间都在集合1的话，直接输出-1。
时间复杂度为
#include
#include
#include
using namespace std;
struct node
{
int pos;
int l ,r;
int ans;
node(int _pos = 0, int _l = 0, int _r = 0, int _ans = 0)
{
pos = _pos;
l = _l;
r = _r;
ans = _ans;
}
bool operator < (const node &p)const
{
if(l != p.l)
{
return l < p.l;
}
return r < p.r;
}
};
bool cmp (const node &a, const node &b)
{
return a.pos < b.pos;
}
vector v;
int main()
{
int t;
scanf("%d", &t);
while(t--)
{
v.clear();
int n;
scanf("%d", &n);
for(int i = 0; i < n; I++)
{
int a, b;
scanf("%d%d", &a, &b);
v.push_back(node(i, a, b));
}
sort(v.begin(), v.end());
int pos = -1;
int r = v[0].r;
for(int i = 1; i < n; I++)
{
if(v[i].l > r)
{
pos = I;
break;
}
r = max(r, v[i].r);
}
if(pos == -1)
{
printf("-1\n");
continue;
}
for(int i = 0; i < n; I++)
{
if(i < pos)v[i].ans = 1;
else v[i].ans = 2;
}
sort(v.begin(), v.end(), cmp);
for(int i = 0; i < n; I++)
{
if(i)printf(" ");
printf("%d", v[i].ans);
}
printf("\n");
}
return 0;
}
Problem D
做完之后看了一下官方题解，官方题解貌似是树分治肛过去的。这里提供另外一种可以卡过去的方法。
首先显然可以得出一个结论：最长链上所有点的权值必定是同一个质数的倍数。
那么问题的重心便可以放在质数上。一个简单的思路是，枚举所有在中的质数，对于每个质数而言，有些点包含这个质数（标记为1），有些点则不包含这个质数（标记为0）。那么问题便可以转化为，给定一个权值只有0和1的树，找出最长的全是1的链。这个问题是一个简单的树DP，可以在内解决。但由于在中的质数过多（差不多是个），所以直接做肯定是超时的。
于是考虑缩减区间范围。注意到当质数大于的时候，节点中权值为质数的倍数的点的权值分解质因数之后，其最大的质因数只可能是。
于是便可以将这个区间分成两个区间来解决：
- 枚举区间中的质数，套用上述的方法。时间复杂度为。
- 对于另外的部分：
- 枚举区间中的质数，对于每个质数而言，枚举所有点，对每个点而言除掉该质数直到无法再整除为止。时间复杂度为。
- 经过第一步的处理之后，所有的点的权值要么是1，要么就是区间中的质数。我们便可以使用树DP的方法在的时间内找到这颗树上除了1以外所有权值相同的链，取最长即可。
总的时间复杂度为。
虽然基本上是卡着时间过的就是了
#include
#include
#include
#include
#include
using namespace std;
struct PrimeList
{
bool vis[200005];
vector List;
int maxa;
void init(int _maxa)
{
maxa = _maxa;
memset(vis, 0, sizeof(vis));
List.clear();
for(int i = 2; i <= maxa; i++)
{
if(!vis[i])
{
List.push_back(i);
for(int j = 2; j * i <= maxa; j++)
{
vis[j * i] = true;
}
}
}
}
bool Find(int &a)
{
if(a * a <= maxa)
{
return false;
}
int l = 0, r = List.size() - 1;
while(r > l)
{
int mid = (l + r) >> 1;
if(List[mid] < a)
{
l = mid + 1;
}
else
{
r = mid;
}
}
return a == List[l];
}
}P;
struct Tree
{
int w[200005];
vector e[200005];
int n;
int dp[200005];
int ans[200005];
bool vis[200005];
void init(int _n)
{
n = _n;
for(int i = 1; i <= n; i++)
{
w[i] = 0;
e[i].clear();
}
memset(vis, 0, sizeof(vis));
}
int dfs(int g, int pos = 1, int prt = -1, bool isUni = false)
{
dp[pos] = 0;
ans[pos] = 0;
if(isUni)
{
if(w[pos] != g)
{
return dp[pos];
}
vis[pos] = true;
}
for(int i = 0; i < e[pos].size(); i++)
{
if(e[pos][i] == prt)
{
continue;
}
dfs(g, e[pos][i], pos, isUni);
dp[pos] = max(dp[pos], dp[e[pos][i]]);
}
if(w[pos] % g == 0)
{
priority_queue< int, vector, greater > q;
for(int i = 0; i < e[pos].size(); i++)
{
if(e[pos][i] == prt)
{
continue;
}
q.push(ans[e[pos][i]]);
if(q.size() > 2)
{
q.pop();
}
}
if(q.size() > 0)
{
ans[pos] = q.top() + 1;
q.pop();
if(q.size() > 0)
{
dp[pos] = max(dp[pos], ans[pos] + q.top());
ans[pos] = q.top() + 1;
}
else
{
dp[pos] = max(dp[pos], ans[pos]);
}
}
else
{
ans[pos] = 1;
dp[pos] = max(dp[pos], 1);
}
}
//printf("dp[%d] = %d[%d]\n", pos, dp[pos], ans[pos]);
return dp[pos];
}
}T;
int main()
{
int n;
while(~scanf("%d", &n))
{
T.init(n);
int maxa = 0;
for(int i = 1; i <= n; i++)
{
int a;
scanf("%d", &a);
T.w[i] = a;
maxa = max(maxa, a);
}
for(int i = 1; i < n; i++)
{
int u, v;
scanf("%d%d", &u, &v);
T.e[u].push_back(v);
T.e[v].push_back(u);
}
P.init(maxa);
int ans = 0;
for(int i = 0; (i < P.List.size()) && (P.List[i] * P.List[i] <= maxa); i++)
{
//printf("%d %d\n", ans, P.List[i]);
ans = max(ans, T.dfs(P.List[i]));
//printf("*%d\n", ans);
for(int j = 1; j <= n; j++)
{
while(T.w[j] % P.List[i] == 0)
{
T.w[j] /= P.List[i];
}
}
}
for(int i = 1; i <= n; i++)
{
if(T.vis[i])
{
continue;
}
if(P.Find(T.w[i]))
{
ans = max(ans, T.dfs(T.w[i], i, -1, true));
}
}
printf("%d\n", ans);
}
return 0;
}
Problem E
首先，不管是wallet还是bill都强制翻转成（）的形式。
然后，对于每个输入，如果是bill的话就去更新和的最大值，否则就拿输入的和分别跟当前的和的最大值比较得到答案。
时间复杂度为。
PS：这E题活的跟道签到题似的噗。。
#include
#include
using namespace std;
int main()
{
int x = 0, y = 0;
int n;
scanf("%d", &n);
while(n--)
{
char s[5];
int px, py;
scanf("%s%d%d", s, &px, &py);
if(px > py)
{
swap(px, py);
}
if(s[0] == '+')
{
x = max(x, px);
y = max(y, py);
}
else
{
if((x > px) || (y > py))
{
printf("NO\n");
}
else
{
printf("YES\n");
}
}
}
return 0;
}