牛客小白月赛D~F

题目链接

---

D.剪纸游戏

题目大意

• 找图案中，存在多少个标准方形

解题思路

• 对于一个未访问的点，递归找它所能到点，记录点个数，
• 

注意 

• 递归中能不定义数组就不定义，因为递归只有在返回时会回收，所以相当于每层都开辟一次空间，空间会出问题
• 递归中调用数组同样耗费时间，像探查方向这类的简短操作，直接分着写要比合着遍历数组写要快很多

 

import java.io.*;
import java.util.Scanner;



public class Main{
    static int n;
    static int m;
	static char[][] map;
    static boolean[][] us;
    static int mxi,mxj,mii,mij,cnt;
	public static void main(String[] args) throws IOException{
		Scanner input=new Scanner(System.in);
        n=input.nextInt();
        m=input.nextInt();
        map=new char[n][m];
	    for(int i=0;i=n||y>=m||us[x][y]||map[x][y]!='.')return;
        us[x][y]=true;
        cnt++;		
		if(mii>x)mii=x;
        if(mij>y)mij=y;
        if(mxi

---

E.可口蛋糕

题目大意

• 每一点有，求对于所有满足的区间，能得到的最大

解题思路

• 区间和，考虑前缀和
• 选择定右端点，找到能满足限制的最大的，则小于的也是满足限制的可选的左端点
• 在找的过程中，记录最小的前缀和
• 则以为右端点的
• 然后，去计算以为右端点的，最后取
• 由于，所以满足限制，则也满足限制，自然之前的也满足
• 所以均不减
• 
• 若选择定左端点，则均要从开始往前走
• 若从1开始，则
• 无法保证也满足限制
• 且的区间变小无法维护最小值

import java.io.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;
/*
 * 函数中要使用数组。将其定义为全局
 * 递归中能分开写的尽量不用数组
 */

 public class Main{
	
	public static void main(String[] args) throws IOException{
		
		AReader input=new AReader();
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    int n=input.nextInt();
	    long W=input.nextLong();
	    long[] w=new long[n+1];
	    long[] d=new long[n+1];
	    for(int i=1;i<=n;++i) {
	    	w[i]=input.nextLong();
	    	w[i]+=w[i-1];
	    }
	    for(int i=1;i<=n;++i) {
	    	d[i]=input.nextLong();
	    	d[i]+=d[i-1];
	    }
	    int i=0;//i-1
	    int j=1;
	    long mi=Long.MAX_VALUE/10;
	    long ans=Long.MIN_VALUE;
	    while(j<=n&&i<=j) {
	    	if(w[j]-w[i]>=W) {//i+1,j
	    		mi=Math.min(mi, d[i]);
	    		i++;
	    	}else {
	    		ans=Math.max(ans, d[j]-mi);
	    		j++;
	    	}
	    }
	    out.println(ans);
		out.flush();
		out.close();
	}
	
	static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
 
        public long nextLong() {
            return Long.parseLong(next());
        }
 
    }
}

 

---

F.喜欢序列

题目大意

• 将一个数组分段，每段段内满足
• 进行次操作，每次对的数值加
• 若设分完段后，每段长度为，则输出每次操作后的

解题思路

• 区间加值，考虑差分
• 由于最后结果与数值大小无关，所以只用记录数值与它前一个数的相对大小
• （由于不需要知道实际大小，所以差分不用求前缀和得出数值，也就不需要树状数组等数据结构）
• 对于一次修改，区间内的无影响，区间外的只可能会影响到所在的段和
• 而影响只有两种
• 当与在一个区间，即 （此时差分已经修改过，原先），则断开
• 当与不在一个区间，但修改后（不算修改，不考虑），则拼接
• 与同理，但由于维护的是向前差分，所以对的相对值，看作判断所在的区间是拼接还是断开（，无意义不考虑）
• (将一次修改看作两次拼接/断开操作，先进行l，产生新的一轮分段，在此基础上，再进行r+1，产生新的分段)
• 例：
• 怎么记录每个点所在的区间，并且避免产生新的区间后，需要重新对区间内的点进行映射更新呢？
• 由于若一个点在某一区间内，则该区间的左端点一定是所有区间中比它小且离它最近的
• 所以不直接记录每个点所在的区间，而是知道点的位置去找区间
• 怎么找？这里引入神奇的
• 内部自动按照键值由小到大进行排序，其内置找小于的最大值
• 完美

import java.io.*;
import java.util.StringTokenizer;
import java.util.TreeMap;


/*
 * 函数中要使用数组。将其定义为全局，写在主函数上面
 * 递归中能分开写的尽量不用数组
 */

 public class Main{
	static long ans;
	static long[] pre;
	static TreeMap qu;
	public static void main(String[] args) throws IOException{
		
		AReader input=new AReader();
//		Scanner input=new Scanner(System.in);
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    int n=input.nextInt();
	    int m=input.nextInt();
	    long[] a=new long[n+1];
	    pre=new long[n+2];
	    a[1]=input.nextLong();
	    for(int i=2;i<=n;++i) {
	    	a[i]=input.nextLong();
	    	pre[i]=a[i]-a[i-1];
	    }
	    ans=0;
	    qu=new TreeMap();
	    for(int i=2,l=1,r=1;i<=n;++i) {
	    	if(a[i]==a[i-1]+1) r++;
	    	else {
	    		qu.put(l, r);
	    		ans+=(long)(r-l+1)*(r-l+1);
	    		l=i;r=i;
	    	}
	    	if(i==n) {
	    		qu.put(l, r);
	    		ans+=(long)(r-l+1)*(r-l+1);
	    	}
	    }
	    
	    while(m>0) {
	    	int l=input.nextInt();
	    	int r=input.nextInt();
	    	long w=input.nextLong();
	    	if(w!=0) {
	    		if(l!=1)update(l, w);
	    		if(r!=n)update(r+1, -w);
	    	}
	    	out.println(ans);
	    	out.flush();
	    	m--;
	    }
		out.flush();
		out.close();
	}
	
	static void update(int x,long w) {
		
		pre[x]+=w;
		if(pre[x]==1) {//拼
			int l=qu.lowerKey(x);//x-1与x原先是断开的，l