7.31 基本算法1.2

 前缀和与差分

介绍：前缀和与差分是一种互补的状态，给定序列A，设其差分序列为B，则序列A的差分序列B的前缀和序列就是原序列A，A的前缀和序列S的差分序列也是原序列A。

              关于一维前缀和，二维前缀和，差分的知识点总结参考：https://blog.csdn.net/K_R_forever/article/details/81775899

 

例题：

poj3263 Tallest cow（区间修改，差分数组，前缀和）

#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
const int maxn = 10010;

map<pair<int,int>, bool>existed;
int c[maxn], d[maxn];

int main(){
    int n, p, h, m;
    cin>>n>>p>>h>>m;
    for(int i = 1; i <= m; i++){
        int a, b;  cin>>a>>b;
        if(a > b)swap(a, b);
        if(existed[make_pair(a,b)])continue;
        d[a+1]--;  d[b]++;
        existed[make_pair(a,b)] = 1;
    }
    for(int i = 1; i <= n; i++){
        c[i] = c[i-1]+d[i];
        cout<<h+c[i]<<'
';
    }
    return 0;
}

思路：求每头牛的相对大小关系，可以想到运用前缀和与差分这一知识点。假设C[p]=0，表示最高的牛为基准且为0，则其他C[i]表示第i头牛与最高牛的身高差距，则i牛的身高为C[i]+H。又因为时间复杂度问题，重复对C[i]数组的操作时间复杂度更高，所以新建立一个D数组为其差分数组，则D的前缀和序列即为C。注意输入区间如果重复则筛去。

 

BZOJ1218（二维前缀和）

 

#include<set>
#include<map>
#include<cstdio>
#include<cmath>
#include<queue>
#include<vector>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 5e3 + 10;
int m[maxn][maxn];
int main()
{
    int n, r;
    scanf("%d%d", &n, &r);
    memset(m, 0, sizeof(m));
    while(n--)
    {
        int x, y, v;
        scanf("%d%d%d", &x, &y, &v);
        m[x + 1][y + 1] = v;
    }
    for(int i = 1; i <= 5001; ++i)
        for(int j = 1; j <= 5001; ++j)
            m[i][j] += m[i][j - 1] + m[i - 1][j] - m[i - 1][j - 1];
    int ans = 0;
    for(int i = r; i <= 5001; ++i)
    {
        for(int j = r; j <= 5001; ++j)
        {
            int x = i - r, y = j - r;
            ans = max(ans, m[i][j] - m[i][y] - m[x][j] + m[x][y]);
        }
    }
    printf("%d
", ans);
    return 0;
}

 

 

思路：

看到块状炸弹式膨胀题型，求某一区域内被计算的个数等，可以考虑矩形二维前缀和，差分方法

 

二分

介绍：  

1.1.最大值最小化：

    //最大值最小化 
    while(l < r){
        int mid = (l + r) >> 1;
        if(a[mid] >= x)  r = mid;   //有可能mid就是答案 
        else  l = mid+1;
    } 

1.2.最小值最大化：

    //最小值最大化
    while(l < r){
        int mid = (l + r + 1) >> 1;
        if(a[mid] >= x)  l = mid;   //有可能mid就是答案 
        else  r = mid - 1;
    } 

 

2.实数域上的二分：

    while(l + 1e-5 < r){
        double mid = (l + r) / 2;
        if(calc(mid))  r = mid;
        else l = mid;
    }

3.三分求单峰函数极值

4.二分答案转化为判定：把求最优解问题，转化为给定一个值mid，判定是否存在一个可行方案（judge函数）达到mid的问题。

 

例题：

POJ 2018（二分查询标记）

 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
double a[100005],b[100005],sum[100005];

int main(){
    int n,L;
    cin>>n>>L;
    for(int i=1;i<=n;i++) scanf("%lf",&a[i]);
    double eps=1e-5;
    double l=-1e6,r=1e6;
    while(r-l>eps){
        double mid=(r+l)/2;
        for(int i=1;i<=n;i++) b[i]=a[i]-mid;
        for(int i=1;i<=n;i++) sum[i]=sum[i-1]+b[i];
        double ans=-1e10,minval=1e10;
        for(int i=L;i<=n;i++){
            minval=min(minval,sum[i-L]);
            ans=max(ans,sum[i]-minval);
        }
        if(ans>=0) l=mid; else r=mid;
    }
    cout<<int(r*1000)<<endl;
    return 0;
}

 

思路：求一个子段，他的和最大，且字段长度不小于L（将数列中的每个数都减去二分的值，通过前缀和判断其其字段和非负）

 

 

POJ 1050（矩阵前缀和）

 

#include<iostream>
#include<cstdio> 
#define ll long long 
#define fo(i,j,n) for(register int i=j; i<=n; ++i)
using namespace std;
int a[105][105],n;
int sum[105][105];
// 矩阵前缀和
void init(){
    fo(i,1,n){
        fo(j,1,n){
            sum[i][j] = sum[i-1][j] + sum[i][j-1] + a[i][j] - sum[i-1][j-1];
        }
    }
}
// 查询矩阵和## 标题
int query(int x1, int y1, int x2, int y2){
    return sum[x2][y2] - sum[x1-1][y2] - sum[x2][y1-1] + sum[x1-1][y1-1];
}
void solve(){
    int MAX = -1e8;
    fo(x1,1,n){
        fo(y1,1,n){
            fo(x2,x1,n){
                fo(y2,y1,n){
                    int t = query(x1,y1,x2,y2);
                    if(t>MAX) {
                        MAX = t;
                    //    cout<<x1<<" " <<y1<<" " <<x2<<" " <<y2<<endl;
                    }
                }
            }
        }
    }
    printf("%d
",MAX);
}
int main(){
    scanf("%d",&n);
    fo(i,1,n){
        fo(j,1,n){
            scanf("%d",&a[i][j]);
        }
    }
    init();
    solve();
    return 0;
}

思考：本题还可以用贪心来优化算法

          当字段区间连续序列和sum小于0时sum归零，是上一道题的变形题，但是没有区间长度大于T的要求限制，即求一个子段，他的和最大

#include<iostream>
#include<cstdio>
#include<cstring>
#define ll long long
#define fo(i,j,n) for(register int i=j; i<=n; ++i)
using namespace std;
const int maxn = 1e4;
int mp[maxn][maxn],n;
int d[maxn];
void solve(){
    int ans = mp[1][1];
    fo(i,1,n){ // i行 
        memset(d,0,sizeof(d)); 
        fo(j,i,n){ // j行 
            fo(k,1,n){ // k列 
                d[k] += mp[j][k]; // d[k] 表示第k列  第i~j行的和(区间和) 
            }
            
            // 接下来的做法就类似一维数组求最大连续序列和 
            int sum = 0;
            fo(k,1,n){
                sum += d[k];
                ans = max(ans,sum);
                if(sum<0) sum=0;
            } 
        }
    }
    printf("%d
", ans);
} 
int main(){
    while(scanf("%d",&n)==1){ // 使程序更加具有鲁棒性 
        fo(i,1,n){
            fo(j,1,n)
                scanf("%d",&mp[i][j]);
        }
        solve();
    }
    return 0;
}

AcWing113

倍增

介绍：

如果状态空间很大，可以通过成倍增长的方式，只递推状态空间中在2的整数次幂位置上的值作为代表，当需要其他位置上的值时，通过“任意整数可以表示成若干个2的次幂项的和”这一性质，使用之前的代表值拼成所需的值。

倍增常与二进制划分两个思想互相结合，包括求解RMQ（区间最值）和ST算法（看书）。

例题：

ch601 genius acm（倍增 + 归并排序）

#include <iostream>
#include <set>
#include <cmath>
#include <stdio.h>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;

LL m, n, t, k;
const int maxn = 5e5 + 5;
LL s[maxn], b[maxn], c[maxn];

bool check(LL l, LL r, LL lr)
{
    LL tot = 0;
    int t = l, len = r - l + 1;
    for(LL i = lr; i <= r; i++){
        b[i] = s[i];
    }
    sort(b + lr, b + r + 1);
    if(l == lr){
        for(int i = l; l <= r; i++){
            c[i] = b[i];
        }
    }
    else{
        int i = l, j = lr;
        while(i < lr && j <= r){
            if(b[i] <= b[j]){
                c[t++] = b[i++];
            }
            else{
                c[t++] = b[j++];
            }
        }
        while(i < lr)c[t++] = b[i++];
        while(j <= r)c[t++] = b[j++];
    }
    LL jiaoyan = 0;
    for(LL i = l; i <= min(l + m - 1, l + (r - l + 1) / 2 - 1); i++){
        jiaoyan += (c[r - i + l] - c[i]) * (c[r - i + l] - c[i]);
    }
    if(jiaoyan <= k){
        for(int i = l; i <= r; i++){
            b[i] = c[i];
        }
        return 1;
    }
    return 0;
}

int main()
{
    scanf("%lld", &t);
    while(t--){
        scanf("%lld%lld%lld", &n, &m, &k);
        for(LL i = 1; i <= n; i++){
            scanf("%lld", &s[i]);
        }

        memset(b, 0, sizeof(b));
        memset(c, 0, sizeof(c));
        LL sum = 0, l = 1, r = 1, p = 1;
        b[1] = s[1];
        while(r < n){
            if(!p){
                sum++;
                p = 1;r++;
                l = r;
                b[l] = s[l];
                continue;
            }
            if(p){
                if(r + p <= n && check(l, r + p, r + 1)){
                    r += p;
                    p *= 2;
                    if(r == n)break;
                }
                else{
                    p /= 2;
                }
            }
            //cout<<sum<<endl;

        }
        if(r == n)sum++;

        printf("%lld
", sum);
    }
}

贪心（策略+寻找最优解）

 

例题：

poj3614 Sunscreen                                                                         

#include<cstdio>
#include<algorithm>
using namespace std;
#define _rep(i,a,b) for(int i=(a);i<=(b);i++)
const int N=2510; 
int c,l,ans;
struct node{
    int minspf,maxspf;
    bool operator <(const node&rhs)const{
    return minspf>rhs.minspf;}
}cow[N];
struct NODE{
    int spf,cover;
    bool operator <(const NODE&rhs)const{
    return spf>rhs.spf;}
}fss[N];
int main()
{
    //freopen("in.txt","r",stdin);
    scanf("%d%d",&c,&l);
    _rep(i,1,c)scanf("%d%d",&cow[i].minspf,&cow[i].maxspf);
    sort(cow+1,cow+1+c);
    _rep(i,1,l)scanf("%d%d",&fss[i].spf,&fss[i].cover);
    sort(fss+1,fss+l+1);
    _rep(i,1,c)
    {
        _rep(j,1,l)
        {
            if(fss[j].cover>0&&fss[j].spf<=cow[i].maxspf&&fss[j].spf>=cow[i].minspf)
            {
                fss[j].cover--;
                ans++;
                break;
            }
        }
    }
    printf("%d
",ans);
    return 0;
}

poj3190 stall reservation

 

#include"iostream"
#include"stdio.h"
#include"queue"
#include"algorithm"
using namespace std;
const int MAXN=50005;
 
struct Node
{
    int s,e,pos;
    friend bool operator<(Node a,Node b)
    {
        if(a.e==b.e) return a.s<b.s;
        return a.e>b.e;
    }
};
 
bool Cmp(Node a,Node b)
{
    if(a.s!=b.s)
        return a.s<b.s;
    else
        return a.e<b.e;
}
 
Node cows[MAXN];
priority_queue<Node>que;
int order[MAXN];
int main()
{
    int n;
    while(scanf("%d",&n)==1)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&cows[i].s,&cows[i].e);
            cows[i].pos=i;
        }
        sort(cows,cows+n,Cmp);
        que.push(cows[0]);
        order[cows[0].pos]=1;
        for(int i=1;i<n;i++)
        {
            if(cows[i].s>que.top().e)
            {
                order[cows[i].pos]=order[que.top().pos];
                que.pop();
                que.push(cows[i]);
            }
            else
            {
                que.push(cows[i]);
                order[cows[i].pos]=que.size();
            }
        }
        cout<<que.size()<<endl;
        for(int i=0;i<n;i++)
        {
            cout<<order[i]<<endl;
        }
    }
    return 0;
}

思路：区间贪心。把尽量多的牛放在一个棚子里，这样就可以使得用到的棚子数最少。只要任意两头牛的挤奶时间不重合，就可以放在一个棚子里。因为N值比较大，先标记好每一头牛的起始坐标，然后按起始时间从小到大进行排序，然后依次从前往后去遍历每一头牛。这里需要用一个优先队列来维护，以结束时间从小到大来维护，每次将一头牛与队列首的牛进行比较，如果满足它的起始时间大于队列首的那头牛的结束时间，这两头牛就可以使用同一个机器，否则就新加一个机器。这里需要注意牛的入队和出队

 

poj1328  radar installation

题意：地图的x轴的上方为海，下方为陆地，海中有n个小岛，坐标为(isl[i].x,isl[i].y)。有一种雷达，能探测到的范围为以d为半径的圆。问海岸线上至少造多少雷达可以把所有的小岛都包含在内。注意雷达是建在海岸线上的，也就是x轴上的。

    #include<iostream>  
    #include<math.h>  
    #include<algorithm>  
    using namespace std;  
    const int Max = 1005;  
      
    struct  
    {  
        int x, y;  
    }isl[Max];    //  小岛的数据。  
      
    struct data  
    {  
        float sta, end;  
    }rad[Max];    //  小岛所对应雷达的数据。  
      
    bool cmp(data a, data b)  
    {  
        if(a.end < b.end)   
            return true;  
        else   
            return false;  
    }  
      
    int main()  
    {  
        int n, d, t = 1;  
        while(cin >> n >> d && n != 0)  
        {  
            int i, j, max_y = 0;  
            for(i = 0; i < n; i ++)  
            {  
                cin >> isl[i].x >> isl[i].y;  
                if(isl[i].y > max_y)  
                    max_y = isl[i].y;  
            }  
            getchar();    
            getchar();  //  PE了两次。  
              
            cout << "Case " << t ++ << ": ";  
            if(max_y > d || d < 0)  
            {  
                cout << -1 << endl;  
                continue;  
            }  
            float len;  
            for(i = 0; i < n; i ++)  
            {   //  求出小岛所对应雷达的可能覆盖范围。  
                len = sqrt(1.0 * d * d - isl[i].y * isl[i].y);  
                rad[i].sta = isl[i].x - len;  
                rad[i].end = isl[i].x + len;  
            }  
            sort(rad, rad + n, cmp);   //  根据rad的end值进行排序。  
              
            int ans = 0;  
            bool vis[Max];  
            memset(vis, false, sizeof(vis));  
            for(i = 0; i < n; i ++)  
            {   //  类似的活动选择。  
                if(!vis[i])  
                {  
                    vis[i] = true;  
                    for(j = 0; j < n; j ++)  
                        if(!vis[j] && rad[j].sta <= rad[i].end)  
                            vis[j] = true;  
                        ans ++;  
                }  
            }  
            cout << ans << endl;  
        }  
        return 0;  
    }  

思路：贪心，从左到右建立雷达，要尽量多地覆盖岛屿。以岛屿为圆心，以d为半径画圆，如果画出的圆与x轴没有交点，则不能实现。存在交点的话，计算出第i个岛屿与x轴的交点坐标保存在结构体数组rad[i].sta与rad[i].end中。对结构体数组排序，按照rad[i].end进行升序排列，然后一次从左到右找雷达。对于rad[i].end为当前最右边的左坐标，对于下一个岛屿，如果rad[j].sta<ran[i].end，则不需要建立新的雷达，需要更新下一个岛屿。否则需要建立新的雷达。

noip2012 国王游戏（洛谷P1080）

 

poj2054  color a tree

参考：https://www.cnblogs.com/yu-chao/archive/2012/02/19/2358565.html