A Yet Another Tetris Problem
所有数奇偶性相同就是yes
import java.util.Scanner;
public class a
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int T = in.nextInt();
while(T>0)
{
T--;
int n = in.nextInt();
int[] cnt = new int[2];
for(int i=1;i<=n;i++)
cnt[in.nextInt()%2]++;
if(cnt[0]==0 || cnt[1]==0)System.out.print("Yes\n");
else System.out.print("No\n");
}
in.close();
}
}
B Yet Another Palindrome Problem
对 ，看看有没有一个 ，且
有就是yes
import java.util.Scanner;
public class b
{
public static void main(String[] argv)
{
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for(int kase=1;kase<=T;kase++)
{
int n = in.nextInt(), i, j;
int[] a = new int[n+5];
for(i=1;i<=n;i++)a[i] = in.nextInt();
soto:
for(i=1;i<=n;i++)
{
for(j=i+2;j<=n;j++)if(a[i]==a[j])
{
System.out.print("YES\n");
break soto;
}
}
if(i>n)System.out.print("NO\n");
}
in.close();
}
}
C Frog Jumps
显然我是没必要去 的（如果我先跳了若干了 然后落在一个 ，我完全可以之前就落在这个 这里）
所以相邻两个 的差的最大值就是答案
import java.util.Scanner;
import java.util.Vector;
import java.util.ArrayList;
import java.lang.Math;
public class c
{
static public void main(String[] argv)
{
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for(int kase=1;kase<=T;kase++)
{
String str = in.next();
int n = str.length();
ArrayList<Integer> pos = new ArrayList<Integer>();
pos.add(0);
for(int i=0;i<n;i++)if(str.charAt(i)=='R')pos.add(i+1);
pos.add(n+1);
int ans=0;
for(int i=1;i<pos.size();i++)
{
ans=Math.max(ans,pos.get(i)-pos.get(i-1));
}
System.out.println(ans);
}
}
}
D Pair of Topics
c++的话可能很好写，拿内置的平衡树搞搞就能解决（pbds）
java我也不知道有没有这种好东西…我反正是先离散化然后树状数组搞的
import java.util.*;
public class d
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int n = in.nextInt(), i;
long ans = 0;
int[] a = new int[n+1], b = new int[n+1];
for(i=1;i<=n;i++)a[i] = in.nextInt();
for(i=1;i<=n;i++)b[i] = in.nextInt();
Lisan ls = new Lisan();
for(i=1;i<=n;i++)
{
ls.insert(a[i]-b[i]);
ls.insert(b[i]-a[i]);
}
ls.sort();
BIT bit = new BIT(2*n);
for(i=1;i<=n;i++)
{
int pos = ls.get(b[i]-a[i])+1;
ans += bit.sum(2*n) - bit.sum(pos);
bit.add( ls.get(a[i]-b[i])+1, +1 );
}
System.out.println(ans);
}
}
class BIT
{
private int[] a;
private int n;
private int lowbit(int x){return x&-x;}
BIT(int n)
{
this.n=n; a=new int[n+1];
}
public int sum(int pos)
{
int ans=0;
for(;pos>0;pos-=lowbit(pos))ans+=a[pos];
return ans;
}
public void add(int pos, int v)
{
for(;pos<=n;pos+=lowbit(pos))a[pos]+=v;
}
}
class Lisan
{
private ArrayList<Integer> tmp;
private Comparator<Integer> c = new Comparator<Integer>()
{
public int compare(Integer a, Integer b)
{
return (int)a-(int)b;
}
};
Lisan()
{
tmp = new ArrayList<Integer>();
}
public void insert(int x)
{
tmp.add(x);
}
public void sort()
{
tmp.sort(c);
}
public int get(int x)
{
int l=0, r=tmp.size()-1;
while(l<r)
{
int mid=l+r>>1;
if(tmp.get(mid)>=x)r=mid;
else l=mid+1;
}
return r;
}
}
E Sleeping Schedule
这题难度应该比不上d的呀…
直接二维dp就行了
import java.util.*;
public class e
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int n, h, l, r, i, j;
n = in.nextInt();
h = in.nextInt();
l = in.nextInt();
r = in.nextInt();
int[] a = new int[n+1];
int[][] dp = new int[n+1][h];
for(i=1;i<=n;i++)a[i] = in.nextInt();
for(i=0;i<=n;i++)for(j=0;j<h;j++)dp[i][j]=-2*n;
dp[0][0]=0;
for(i=0;i<n;i++)
{
for(j=0;j<h;j++)
{
int to = (j+a[i+1])%h;
int add = to>=l && to<=r ? 1 : 0;
dp[i+1][to] = Math.max(dp[i+1][to],dp[i][j]+add);
to = (j+a[i+1]+h-1)%h;
add = to>=l && to<=r ? 1 : 0;
dp[i+1][to] = Math.max(dp[i+1][to],dp[i][j]+add);
}
}
int ans=0;
for(j=0;j<h;j++)ans=Math.max(ans,dp[n][j]);
System.out.println(ans);
}
}
F Maximum White Subtree
这种题就要先想序列上怎么做，然后推广到树上去
先想序列上怎么做
一种十分容易想到的方法就是转化成两个前缀和的差( )，但是这个没法往树上推广，因为前后不是那么简单的线性关系
序列上还可以这么做：维护以 为开头的白减黑的最大值，维护以 为结尾的白减黑的最大值，加起来就是这个点的答案（当然如果前面那段比 小我可以选择不加它）
这个方法似乎就更容易往树上推广了
往树上推广
用 表示强制包含 这个点的，以 为根的子树的连通块的"白减黑"最大值。
一次 就可以求出全部的
那么这个 就相当于序列上的“以 为开头的白减黑最大值”，下面还需要把“以 为结尾的白减黑的最大值”推广到树上
这个也容易，我第二遍 的时候一边往下走一边推出这个值就行了
import java.util.*;
public class f
{
static private int[] f, dp, c;
static private int n;
static void dfs1(Graph G, int u, int fa)
{
ArrayList<Integer> to = G.get(u);
if(c[u]==1)f[u]=1;
else f[u]=-1;
for(int i=0;i<to.size();i++)
{
int v = (int)to.get(i);
if(v!=fa)
{
dfs1(G,v,u);
f[u] += Math.max(0,f[v]);
}
}
}
static void dfs2(Graph G, int u, int fa, int mx)
{
ArrayList<Integer> to = G.get(u);
dp[u] = f[u] + Math.max(0,mx);
mx = Math.max(mx,0);
if(c[u]==1)mx+=1;
else mx-=1;
for(int i=0;i<to.size();i++)
{
int v = (int)to.get(i);
if(v==fa)continue;
mx += Math.max(0,f[v]);
}
for(int i=0;i<to.size();i++)
{
int v = (int)to.get(i);
if(v==fa)continue;
dfs2(G,v,u,mx-Math.max(0,f[v]));
}
}
static public void main(String[] args)
{
Scanner in = new Scanner(System.in);
int u, v, i;
n = in.nextInt();
c = new int[n+1];
for(i=1;i<=n;i++)
c[i] = in.nextInt();
Graph G = new Graph(n);
for(i=1;i<n;i++)
{
u = in.nextInt();
v = in.nextInt();
G.adde(u,v);
G.adde(v,u);
}
f = new int[n+1];
dp = new int[n+1];
dfs1(G,1,0);
dfs2(G,1,0,0);
for(i=1;i<=n;i++)System.out.print(dp[i]+" ");
}
}
class Graph
{
private ArrayList<ArrayList<Integer>> e;
Graph(int n)
{
e = new ArrayList<ArrayList<Integer>>();
for(int i=0;i<=n;i++)e.add(new ArrayList<Integer>());
}
public ArrayList<Integer> get(int u)
{
return e.get(u);
}
public void adde(int u, int v)
{
ArrayList<Integer> al = get(u);
al.add(v);
}
}
