T2862
数学
class Solution {
public long maximumSum(List<Integer> nums) {
List<Integer> pf = new ArrayList<>();
int n = nums.size();
if(n == 1) return nums.get(0);
long ans = 0;
int i = 1;
while(i<=n){
pf.add(i*i);
i+=1;
}
int[] vis = new int[n+1];
for(i = 1;i<=n;i++){
if(vis[i] == 1) continue;
int cnt = 0;
long s = 0;
while(i*pf.get(cnt)<=n){
s+=nums.get(i*pf.get(cnt)-1);
vis[i*pf.get(cnt)] = 1;
cnt+=1;
}
ans = Math.max(ans,s);
}
return ans;
}
}T1483
树上倍增（st表）
思路
一个很朴素的想法求树上某节点的第k个祖先的方法就是从该节点往上跳k次，到达的节点就是所求的节点。但是根据题目要求的最大5*10^4的查询次数，这样做显然不符合题意。考虑快速幂这样的算法，正常求一个数x的n次幂是将x直接累乘n次，时间复杂度是O(n)，而对于快速幂算法，将累乘次数n用二进制的方式表示，可以发现实际上x^n = x^(a0*2^0+a1*2^1+...+ak*2^k)，其中（ai 属于 {0,1})，这样把累乘n次换成了累加log n次，时间复杂度就降低了许多。
同样地，本题基于快速幂的思想，我们要额外考虑如何记录某一节点的第2^i个祖先：记节点j的第2^i个祖先为pa[j][i]，实际上节点j的第2^i个祖先就是j的第2^(i-1)个祖先的第2^(i-1)个祖先，那么我们就可以得到以下递推式pa[j][i] = pa[pa[j][i-1]][i-1]。
最后，在预处理得到某一节点的第2^i个祖先以后，通过快速幂的思想我们就可以在log k的时间内找到某一节点的第k个祖先。
class TreeAncestor {
private int[][] pa;
public TreeAncestor(int n, int[] parent) {
String s = Integer.toBinaryString(n);
int m = s.length();
pa = new int[n][m];
for(int i = 0;i<n;i++){
Arrays.fill(pa[i],-1);
}
for(int i = 0;i<n;i++){
pa[i][0] = parent[i];
}
for(int i = 1;i<m;i++){
for(int k = 0;k<n;k++){
if(pa[k][i-1]!=-1){
pa[k][i] = pa[pa[k][i-1]][i-1];
}
}
}
}
public int getKthAncestor(int node, int k) {
int cnt = 0;
while(k>0){
if((k&1)==1){
node= pa[node][cnt];
if(node == -1){
return -1;
}
}
cnt+=1;
k>>=1;
}
return node;
}
}
T2846
tarjan算法离线求LCA
思路
首先考虑如何计算出结果，答案是很显然的，即把所要求查询的路径上的所有边的权重变为出现频率最大的权重，结果即为路径长度-出现频率最大的权重的频数。接下来考虑以下两个子问题：1、如何求两个节点的路径长度；2、如何求路径中出现频率最大的权重的频数。
1、对于求两个节点的路径长度。因为本题的数据结构是无向树，显然选取任意节点作为根节点对于结果无影响，为了方便计算，我们取编号为0的节点作为根结点。对于两个节点的路径长度，考虑其的最近公共祖先节点（LCA），记两个节点分别为u，v，其最近公共祖先节点为lca（u，v），记某一节点x到根结点的深度为h[x]，那么两个节点之间的路径长度即为dis(u,v)=h[u]+h[v]-2*h[lca(u,v)]。其中h可以通过树的深度优先遍历获取，lca(u,v)可以通过tarjan算法离线获取，篇幅有限不做过多赘述。
2、如何求路径中出现频率最大的权重的频数。注意到w的权重范围(0<wi<=26)，显然我们可以直接存储每一个节点u到根结点的每一个权重的频数，记为w[u]，那么路径中某一权重的出现频数即为weigh(u,v,i) = w[u][i]+w[v][i]-2*w[lca(u,v)][i]，其中i为值属于(1,27)的权重值，w[u][i]可以通过树的深度优先遍历获取。最后我们取max(weigh(u,v,i))即为路径中出现频率最大的权重的频数。
最后，我们可以得到每一次查询的结果即为dis(u,v) - max(weigh(u,v,i))。
class Solution {
//定义全局变量
int[] fa;
int[] h;
int[][] w;
int[] vis;
int[] lca;
Map<Integer,Integer> query = new HashMap<>();
public int[] minOperationsQueries(int n, int[][] edges, int[][] queries) {
h = new int[n];
w = new int[n][27];
List<int[]>[] nei = new ArrayList[n];
Arrays.setAll(nei,e->new ArrayList<>());
for(var e:edges){
int a = e[0],b = e[1],c = e[2];
nei[a].add(new int[]{b,c});
nei[b].add(new int[]{a,c});
}
dfs(0,-1,1,nei);
fa = new int[n];
for(int i = 0;i<n;i++){
fa[i] = i;
}
List<int[]>[] query = new ArrayList[n];
Arrays.setAll(query,e->new ArrayList<>());
int cnt = 0;
for(var q:queries){
int a = q[0],b = q[1];
query[a].add(new int[]{b,cnt});
query[b].add(new int[]{a,cnt});
cnt+=1;
}
lca = new int[cnt];
vis = new int[n];
tarjan(0,-1,query,nei);
int[] ans = new int[cnt];
cnt = 0;
for(var q:queries){
int ancestor = lca[cnt];
int nn = h[q[0]]+h[q[1]] - 2*h[ancestor];
int delete = 0;
for(int k = 1;k<27;k++){
delete = Math.max(delete,w[q[0]][k]+w[q[1]][k]-2*w[ancestor][k]);
}
ans[cnt] = nn- delete;
cnt+=1;
}
return ans;
}
//dfs求根节点到所有结点的深度和26条不同边的权重
public void dfs(int cur,int f,int deep,List<int[]>[] nei){
for(var nxt:nei[cur]){
int j = nxt[0];
if(j == f) continue;
h[j] = deep;
int weight = nxt[1];
for(int i = 1;i<27;i++){
w[j][i] = w[cur][i];
if(i==weight){
w[j][i]+=1;
}
}
dfs(j,cur,deep+1,nei);
}
}
//并查集
public int find(int x){
if(fa[x]!=x){
fa[x] = find(fa[x]);
}
return fa[x];
}
//tarjan算法求LCA
public void tarjan(int cur,int f,List<int[]>[] query,List<int[]>[] nei){
for(var nxt:nei[cur]){
int j = nxt[0];
if(j == f || vis[j]==1) continue;
tarjan(j,cur,query,nei);
fa[j] = cur;
}
vis[cur] = 1;
for(var q:query[cur]){
if(vis[q[0]]==1){
lca[q[1]] = find(q[0]);
}
}
}
}T2827
数位DP
class Solution {
public int numberOfBeautifulIntegers(int low, int high, int k) {
return calc(high,k)-calc(low-1,k);
}
public int calc(int lim,int k){
String s = Integer.toString(lim);
int n = s.length();
int[][][] cache = new int[n][k][n*2+1];
for(int i = 0;i<n;i++){
for(int j = 0;j<k;j++){
Arrays.fill(cache[i][j],-1);
}
}
return f(0,0,0,true,false,k,s,n,cache);
}
public int f(int i,int mask,int sub,boolean isLimit,boolean isPrenum,int k,String s,int n,int[][][] cache){
if(i == n){
if(isPrenum==true&&mask==0&&sub==0) return 1;
return 0;
}
if(isLimit==false&&isPrenum==true&&cache[i][sub][mask+n]!=-1){
return cache[i][sub][mask+n];
}
int res = 0;
if(isPrenum == false){
res = f(i+1,0,0,false,false,k,s,n,cache);
}
int up = isLimit == true?(int)(s.charAt(i)-'0'):9;
int low = isPrenum == true?0:1;
for(int d = low;d<up+1;d++){
int tmp = d%2==1?1:-1;
res+=f(i+1,mask+tmp,(sub*10+d)%k,isLimit&&d==up,true,k,s,n,cache);
}
if(isLimit==false&&isPrenum==true){
cache[i][sub][mask+n] = res;
}
return res;
}
}T2836
树上倍增（st表）
思路
注意到要传k次球，而k的数据类型是long，因此直接用暴力递归求f(n)的写法显然是会超时不符题意的。考虑到T1483的算法思路，同样地，我们把k分解为二进制，即k=a0*2^0+a1*2^1+...+ai*2^i，
class Solution {
public long getMaxFunctionValue(List<Integer> receiver, long k) {
int n = receiver.size();
String kk = Long.toBinaryString(k);
int m = kk.length();
int[][] pa = new int[n][m];
for(int i = 0;i<n;i++){
pa[i][0] = receiver.get(i);
}
for(int i = 1;i<m;i++){
for(int j = 0;j<n;j++){
pa[j][i] = pa[pa[j][i-1]][i-1];
}
}
long[][] w = new long[n][m];
for(int i = 0;i<n;i++){
w[i][0] = receiver.get(i);
}
for(int i = 1;i<m;i++){
for(int j = 0;j<n;j++){
w[j][i] = w[j][i-1]+w[pa[j][i-1]][i-1];
}
}
long ans = 0;
for(int i = 0;i<n;i++){
long tmp = k;
long f = i;
int deep = 0;
int cur = i;
while(tmp>0){
if((tmp&1) == 1){
f+=w[cur][deep];
cur = pa[cur][deep];
}
tmp/=2;
deep+=1;
}
ans = Math.max(ans,f);
}
return ans;
}
}T2646
树形dp
class Solution {
Deque<Integer> path = new ArrayDeque<>();
Map<Integer,Integer> cnt = new HashMap<>();
public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] trips) {
List<int[]>[] nei = new ArrayList[n];
Arrays.setAll(nei,e->new ArrayList<>());
for(var e:edges){
nei[e[0]].add(new int[]{e[1]});
nei[e[1]].add(new int[]{e[0]});
}
for(var t:trips){
dfs(t[0],-1,t[1],nei);
}
int[] res = dp(0,-1,price,nei);
return Math.min(res[0],res[1]);
}
public void dfs(int i,int fa,int target,List<int[]>[] nei){
if(i==target){
path.add(target);
for(var node:path){
if(cnt.containsKey(node)==false){
cnt.put(node,1);
}
else{
cnt.merge(node,1,(a,b)->(a+b));
}
}
path.pollLast();
}
else{
for(var j:nei[i]){
if(j[0]==fa) continue;
path.add(i);
dfs(j[0],i,target,nei);
path.pollLast();
}
}
}
public int[] dp(int i,int fa,int[] price,List<int[]>[] nei){
int v = 0,half_v = 0;
if(cnt.containsKey(i)){
v = price[i]*cnt.get(i);
half_v = price[i]/2*cnt.get(i);
}
for(var j:nei[i]){
if(j[0]==fa) continue;
int[] tmp = dp(j[0],i,price,nei);
half_v+=tmp[0];
v+=Math.min(tmp[0],tmp[1]);
}
return new int[]{v,half_v};
}
}T42
单调栈
class Solution {
public int trap(int[] height) {
Deque<Integer> st = new ArrayDeque<>();
int ans = 0;
for(int i = 0;i<height.length;i++){
while(st.isEmpty()==false&&height[i]>height[st.peekLast()]){
int tmp = st.pollLast();
if(st.isEmpty()==false){
int w = i-st.peekLast()-1;
int hei = Math.min(height[st.peekLast()],height[i])-height[tmp];
ans+=hei*w;
}
}
st.add(i);
}
return ans;
}
}T2842
暴力dfs
class Solution {
final int MOD = (int)1e9+7;
long ans = 0;
Map<String,Integer> cnt = new HashMap<>();
List<String>key = new ArrayList<>();
long target = 0;
public int countKSubsequencesWithMaxBeauty(String s, int k) {
for(int i = 0;i<s.length();i++){
String c = s.substring(i,i+1);
if(cnt.containsKey(c)==true){
cnt.merge(c,1,(old,new_)->(old+new_));
}
else{
cnt.put(c,1);
key.add(c);
}
}
if(k>cnt.size()) return 0;
List<Integer> sort_v = new ArrayList<>();
for(int i = 0;i<key.size();i++){
sort_v.add(cnt.get(key.get(i)));
}
Collections.sort(sort_v,(a,b)->(b-a));
for(int i = 0;i<k;i++){
target+=sort_v.get(i);
}
dfs(0,0,0,k,1);
return (int)ans;
}
public void dfs(int i,long cur_sum,int deep,int k,long mul){
if(deep == k){
if(cur_sum == target){
ans = (ans+mul)%MOD;
}
return;
}
if(i+k-deep>key.size()||i>=key.size()){
return;
}
int tmp = cnt.get(key.get(i));
dfs(i+1,cur_sum+tmp,deep+1,k,mul*tmp%MOD);
dfs(i+1,cur_sum,deep,k,mul);
}
}T1388
状态机dp
class Solution {
public int maxSizeSlices(int[] slices) {
int n = slices.length;
return Math.max(f(Arrays.copyOfRange(slices,1,n)),f(Arrays.copyOfRange(slices,0,n-1)));
}
public int f(int[] slices){
int n = slices.length;
int k = (n+1)/3;
int[][] dp = new int[n][k+1];
dp[0][1] = slices[0];
dp[1][1] = Math.max(slices[0],slices[1]);
int ans = 0;
for(int i = 0;i<n;i++){
for(int j = 1;j<k+1;j++){
if(i>1){
dp[i][j] = Math.max(dp[i-1][j],dp[i-2][j-1]+slices[i]);
}
if(j==k){
ans = Math.max(ans,dp[i][j]);
}
}
}
return ans;
}
}T1444
二维前缀和+记忆化搜索
class Solution {
final int MOD = (int)1e9+7;
int[][] martrix;
int[][][] cache;
public int ways(String[] pizza, int k) {
int m = pizza.length;
int n = pizza[0].length();
//记忆化搜索
cache = new int[m+1][n+1][k+1];
for(int i = 0;i<m+1;i++){
for(int j = 0;j<n+1;j++){
Arrays.fill(cache[i][j],-1);
}
}
martrix = new int[m+1][n+1];
for(int i = 1;i<=m;i++){
for(int j = 1;j<=n;j++){
int tmp = 0;
if(pizza[i-1].charAt(j-1)=='A') tmp = 1;
martrix[i][j] = martrix[i-1][j]+martrix[i][j-1]-martrix[i-1][j-1]+tmp;
}
}
return dfs(0,0,1,m,n,k)%MOD;
}
public int find(int row,int col,int mrow,int ncol){
return martrix[mrow][ncol]+martrix[row][col]-martrix[mrow][col]-martrix[row][ncol];
}
public int dfs(int i,int j,int deep,int m,int n,int k){
if(deep == k){
return find(i,j,m,n)>0?1:0;
}
if(cache[i][j][deep]>=0) return cache[i][j][deep];
int res = 0;
for(int row = i+1;row<m;row++){
if(find(i,j,row,n)>0){
res=(res+dfs(row,j,deep+1,m,n,k))%MOD;
}
}
for(int col = j+1;col<n;col++){
if(find(i,j,m,col)>0){
res=(res+dfs(i,col,deep+1,m,n,k))%MOD;
}
}
return cache[i][j][deep] = res;
}
}
2051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
