前缀和与差分的学习记录

前缀和与差分的学习

嗯，之前学过也不写什么捏
也就二维前缀和比较重要捏

找到最高海拔两种做法捏

最高的牛
两个可看到的牛中间都-1，但是注意不能重复哦！！！

#include <bits/stdc++.h>
using namespace std;
int a[10100],b[10100];
int main()
{
    int len,pos,h,ask;cin >> len >>pos >>h>>ask;
    // 两个可以相互看见的之间的身高都会比他们两个-1
    // 还有就再次减
    int res[len]={0};
    res[0]=h;
    //   h  -1  0   1  0  0
    //   h  h-1 h-1 h  h  h
    int x,y;
    for (int i = 0; i < ask; i++)
    {
        cin >> x>>y;
        if (x>y)
        {
            swap(x,y);
        }
        a[i]=x;
        b[i]=y;
        // 防止有重复的条件
        for (int j = 0; j < i; j++)
        {
            if (a[i]==a[j]&&b[i]==b[j])
            {
                res[x]++;
                res[y-1]--;
                break;
            }
            
        }
        res[x]--;
        res[y-1]++;
    }
    int s[len];
    s[0]=res[0];
    cout << s[0]<<endl;
    for (int i = 1; i < len; i++)
    {
        s[i] = res[i]+s[i-1];
        cout << s[i] <<endl;
    }
}

积木大赛
想到了其他方法，不需要拆分捏，就是类似上山，算了上山的路，就不需要计算下山的路

int main()
{
    int len,x;cin >>len;
    int temp=0,res=0,cur=0,flag=0;
    for (int i = 0; i < len; i++)
    {
        cin >> x;
        if (x>temp)
        // 只要后面的比前面高，那么就可以一直往上堆
        // 但是如果后面比前面低，那就可以不管了
        // 就是相当于，你只用计算上坡的路段/上坡的路段，不用担心下坡
        // 因为有上坡必有下坡
        {
            temp =x;
            flag = 1;
        }
        if (x<temp)
        {
            if (flag==1)
            {
                res += temp - cur;
                temp = x;
                cur = x;
                flag=0;
                // 结束上坡的时候
            }
            else
            {
                temp = x;
                cur = x;
                // 预备上坡，所以要准备好最低点
            }
        }
    }   
    cout << res +temp-cur;
}

k倍区间这个不就是二面的考核题吗？氢氢竦竦

和为k的子序列
其实就是二面的简单版，因为只要相等就可以了

最大子序和（用暴力超时捏）
明天再看看dp

领域均值这题二维前缀和，嗯挺好的，下面有注解

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int len,l,r,t;cin >>len>>l>>r>>t;
    int record[len+1][len+1]={0},x=0,res=0;
    for (int i = 1; i < len+1; i++)
    {
        for (int j = 1; j < len+1; j++)
        {
            cin >>x;
            // 因为是从左向右，从上向下，所以左边和上面的全部都是知道的，
            record[i][j]=record[i-1][j]+record[i][j-1]-record[i-1][j-1]+x;
            //        上一行，左右面     左一列，上下面积  前面两者重叠面积  目前位置的值
        }
    }
    for (int i = 1; i < len+1; i++)
    // 为什么要从1开始，组合的时候上面也是
    // 因为下面计算的时候，有x-1，y-1，如果x=0，那不就是越界了吗？
    // 但是你又没有其他地方给他重新赋值呀，所以不如开大一点
    // 酱紫x-1不就自动成为0了吗？
    {
        for (int j = 1; j < len+1; j++)
        {
            int s, m;
            int x1, y1, x2, y2;//得出区域的右下角和左上角
            x1 = max(1, i - r);
            y1 = max(1, j - r);
            x2 = min(len, i + r);
            y2 = min(len, j + r);
            // 上面操作是防止越位，将矩阵放在里面
            s = record[x2][y2] - record[x1 - 1][y2] - record[x2][y1 - 1] + record[x1 - 1][y1 - 1];
            //计算前缀和，就是相当于组合的时候的逆向，因为钱的不分不是一个元素，是多个，是一个二维数组
            // 所以，和上面组合的时候使用 x不一样，因为x只代表一个值
            m = (y2 + 1-y1) * (x2+1 - x1 ); 
            //   计算元素数量，相当于计算长方形面积
            // 但是需要扩大一个单位，因为这是下标，我们要的是类似切片的长度
            if(s <= t * m) 
            {
                res ++;
                
            } //判断是否小于等于t
        }
    }
    cout << res;
}