如何使用python自动关闭使用照片应用打开的程序

Picture poj 1177

链接

题意

给出n个矩形的左下角坐标和右上角坐标，让求n个矩形形成的不规则图形的轮廓周长，即矩形周长并。

题解

线段树+扫描线。
一般扫描线都会离散化。

先算与x轴平行的轮廓，对于与y轴平行的类似于x轴的。

首先我们把所有的与x轴平行的直线搞到结构体中，如果是矩形的下边，给它一个id为1，上边id为-1。

按照边的高度从小到大排序。

线段树中维护的信息有

struct Tree
{
    int tag,sum;//tag表示这个节点所表示的线段被完整覆盖了几次，sum表示这个节点所表示的线段被覆盖的长度。
} node[N*4];

遍历所有的边，并更新到线段树中，如果这条边的id是1，相当于把这个线段更新到线段树中，如果是-1，相当于把这个线段从线段树中抹去。

那么当前线段贡献的周长是，当前的总长度减去上一次的总长度 的绝对值（自己模拟一下就理解了）

假设有2个矩形如下：

y轴就跟x轴一样，再做一遍上述操作就可以了。

参考博客

代码

//#include<bits/stdc++.h>
#include<math.h>
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<vector>
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N=1e4+10;
const float PI =acos(-1.0);
const int mod=1e9+7;
const int inf=0x3f3f3f3f;

struct seg
{
    int l,r,h,id;
    seg() {}
    seg(int a,int b,int c,int d):l(a),r(b),h(c),id(d) {}
    bool operator <(const seg& a)const
    {
        return h<a.h;
    }
} arr[2][N];
vector<int>vec[2];
int getid(int x,int pos)
{
    return lower_bound(vec[pos].begin(),vec[pos].end(),x)-vec[pos].begin()+1;
}
struct Tree
{
    int tag,sum;
} node[N*4];
void pushup(int rt,int l,int r,int p)
{
    if(node[rt].tag) node[rt].sum=vec[p][r]-vec[p][l-1];//如果tag大于0说明此此线段至少被覆盖一次，长度就是区间的长度
    else node[rt].sum=node[rt*2].sum+node[rt*2+1].sum;
}
void update(int rt,int l,int r,int qs,int qe,int id,int p)
{
    if(qs<=l&&qe>=r)
    {
        node[rt].tag+=id;
        pushup(rt,l,r,p);//这里也必须使用pushup，因为如果这次更新变成0了，还需要使用子节点的长度来更新
        return;
    }
    int mid=(l+r)/2;
    if(qs<=mid) update(rt*2,l,mid,qs,qe,id,p);
    if(qe>mid) update(rt*2+1,mid+1,r,qs,qe,id,p);
    pushup(rt,l,r,p);
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1; i<=n; i++)
        {
            int x1,y1,x2,y2;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            vec[0].pb(x1),vec[0].pb(x2);//vector用于离散化
            vec[1].pb(y1),vec[1].pb(y2);
            arr[0][i]=seg(x1,x2,y1,1);//获取线段
            arr[0][i+n]=seg(x1,x2,y2,-1);
            arr[1][i]=seg(y1,y2,x1,1);
            arr[1][i+n]=seg(y1,y2,x2,-1);
        }
        n<<=1;
        sort(arr[1]+1,arr[1]+1+n);//对线段按照高度排序
        sort(arr[0]+1,arr[0]+1+n);
        sort(vec[0].begin(),vec[0].end());//对要离散化的点进行排序
        sort(vec[1].begin(),vec[1].end());
        vec[0].erase(unique(vec[0].begin(),vec[0].end()),vec[0].end());
        vec[1].erase(unique(vec[1].begin(),vec[1].end()),vec[1].end());//删除vector重复的点
        int ans=0;
        for(int i=0; i<2; i++)
        {
            int now=0,pre=0;
            memset(node,0,sizeof(node));
            for(int j=1; j<=n; j++)
            {
                int l=getid(arr[i][j].l,i);//获取离散化后的值
                int r=getid(arr[i][j].r,i);
                if(l<r) update(1,1,vec[i].size(),l,r-1,arr[i][j].id,i);//为什么使用的是r-1？
                //因为有l==r的区间，这样区间长度为0，所以我们让每个区间表示[l,r+1]的长度，这样更新的时候就需要更新[l,r-1]。
                //上面的pushup时完整区间的长度就是算的[l,r+1]，这是对于r-1较好的解释了
                ans+=abs(node[1].sum-pre);//差值是贡献，模拟一下就知道了
                pre=node[1].sum;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
/*
7
-15 0 5 10
-5 8 20 25
15 -4 24 14
0 -6 16 4
2 15 10 22
30 10 36 20
34 0 40 16
*/

关于更新时r-1的解释参考博客链接