2013多校第三场

hdu 4629

题意：给你n个三角形，问覆盖1~n次的面积各是多少，n < 50;

分析：取出所有端点和交点的x坐标，排序，然后对于每一段xi~xi+1的范围的线段都是不相交的，所以组成的

面积要么是三角形，要么是梯形，可以直接用公式算面积，然后对于每一个三角形的线段都标记该段对于

从下往上的扫描线来说是入边还是出边，然后就可以直接计算出这块面积被覆盖了几次；如入边加1，出边减一

下图，黄色表示覆盖次数；

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<cstdlib>
#define pbk push_back
using namespace std;
const int N = 25050+10;
const double eps = 1e-10;
inline double sqr(double x){
    return x * x;
}
inline int dcmp(double x){
    return x < -eps ? -1 : x > eps;
}
struct Point{
    double x,y;
    int kind;
    Point(){}
    Point(double x,double y,int kind = 0):x(x),y(y),kind(kind){}
    bool operator < (const Point &p)const{
        return dcmp(x - p.x) < 0 || ( dcmp(x - p.x) == 0 && dcmp(y - p.y) < 0 );
    }
    Point operator - (const Point &p)const{
        return Point(x - p.x, y - p.y);
    }
    Point operator + (const Point &p)const{
        return Point(x + p.x, y + p.y);
    }
    Point operator * (const double &k)const{
        return Point (x*k , y*k);
    }
    Point operator / (const double &k)const{
        return Point (x/k, y/k);
    }
    double operator * (const Point &p)const{
        return x * p.y - y * p.x;
    }
    double operator / (const Point &p)const{
        return x * p.x + y * p.y;
    }
    void input(){
        scanf("%lf%lf",&x,&y);
    }
    void ot(){
        printf("%lf %lf
",x,y);
    }
};
struct Line{
    Point a,b;
    int kind;
    Line (){}
    Line (Point a,Point b,int kind = 0):a(a),b(b),kind(kind){}
    double operator * (const Point &p)const{
        return ( b - a ) * ( p - a );
    }
    double operator / (const Point &p)const{
        return ( p - a) / ( p - b);
    }
    bool parallel(const Line &v){
        return !dcmp( ( b - a ) * ( v.b - v.a ) ); 
    }
    int LineCrossLine(const Line &v){
        if ( (*this).parallel(v) ){
            return ( dcmp( v * a ) == 0);
        }return 2;
    }
    int SegCrossSeg(const Line &v){
        int d1 = dcmp( (*this) * v.a);
        int d2 = dcmp( (*this) * v.b);
        int d3 = dcmp( v * a);
        int d4 = dcmp( v * b);
        if ( ( d1 ^ d2 ) == -2 && ( d3 ^ d4 ) == -2 ) return 2;
        return ( ( d1 == 0 && dcmp( (*this) / v.a ) <= 0 )
            ||   ( d2 == 0 && dcmp( (*this) / v.b ) <= 0 )
            ||   ( d3 == 0 && dcmp( v / a ) <= 0 )
            ||   ( d4 == 0 && dcmp( v / b ) <= 0 )
            );
    }
    Point CrossPoint(const Line &v){
        double s1 = v * a, s2 = v * b;
        return ( a * s2 - b * s1) / (s2 - s1);
    }
    void input(){
        a.input(); b.input();
    }
    void ot(){
        a.ot(); b.ot();
    }

};

int n,poly_n,xn;
vector<double> lx;
vector<Line> line;
double ans[N];
void init(){
    int sz = line.size();
    for (int i = 0; i < sz; i++){
        for (int j = i+1; j < sz; j++){
            if (line[i].SegCrossSeg(line[j]) == 2){
                Point p = line[i].CrossPoint(line[j]);
                lx.pbk(p.x);
            }
        }
    }
    
    sort(lx.begin(),lx.end());
    xn = unique(lx.begin(),lx.end()) - lx.begin();
}
vector<Point> qu[N];
void work(){
    for (int i = 0; i <= n; i++) ans[i] = 0;
    for (int i = 0; i < xn-1; i++){
        int k = 0;
        for (int j = 0; j+1 < qu[i].size(); j++){
            k += qu[i][j].kind;
            ans[ k ] += (lx[i+1] - lx[i]) * (qu[i][j+1].x+qu[i][j+1].y - qu[i][j].x - qu[i][j].y) / 2;        
        }
    }
    for (int i = 1; i <= n; i++) printf("%.10lf
",ans[i]);
}
void check(){
    for (int i = 0; i < xn - 1; i++){
        cout<<qu[i].size()<<" >.<"<<endl;
        for (int j = 0; j < qu[i].size(); j++){
            qu[i][j].ot(); cout<<qu[i][j].kind<<endl;
        }
    }
}
void solve(){
    for (int i = 0; i < xn; i++) qu[i].clear();
    for (int i = 0; i < line.size(); i++){
        int j = lower_bound(lx.begin(),lx.begin()+xn,line[i].a.x) - lx.begin();
        for (; j+1 < xn; j++ ){
            double l = lx[j], r = lx[j+1];
            if (dcmp(r - line[i].b.x) > 0) break;
            Point p1 = line[i].CrossPoint(Line(Point(l,0), Point(l,1)));
            Point p2 = line[i].CrossPoint(Line(Point(r,0), Point(r,1)));
            qu[j].pbk(Point(p1.y, p2.y,line[i].kind));
        }
    }
    for (int i = 0; i < xn - 1; i++) sort(qu[i].begin(), qu[i].end());
//    check();
    work();
}
int main(){
    int T; scanf("%d",&T);
    while (T--){
        scanf("%d",&n);
        lx.clear(); line.clear();;
        for (int i = 0; i < n ;i++){
            Point t[4];
            for (int j = 0; j < 3; j++ ){
                t[j].input(); 
            }
            t[3] = t[0];
            int flag = 1;
            if (dcmp( (t[1] - t[0])*(t[2] - t[0]) ) == 0) flag = 0;
        
            for (int i = 0; i < 3 && flag; i++ ){
                lx.pbk(t[i].x);
                for (int j = i+1; j < 3; j++){
                    Line tmp; tmp.a = t[i]; tmp.b = t[j];
                    if (dcmp( tmp.a.x - tmp.b.x ) > 0) swap(tmp.a, tmp.b);
                    
                    Line tmp2 = Line(t[3-i-j], Point(t[3-i-j].x, t[3-i-j].y - 1));
                    if (tmp.LineCrossLine(tmp2) != 2) continue;
                    Point tp = tmp.CrossPoint(tmp2);
                    if (dcmp(tp.y - t[3-i-j].y) < 0) tmp.kind = 1;
                        else tmp.kind = -1;    
                    line.pbk(tmp);
                }
            }
        }
        init();
        solve();    
    }
    return 0;
}

hdu 4622

题意：给你一个长n的串，Q次询问其子串s[l,r]中不同的串的个数；

分析：正解后缀自动机，或者HASH，比赛的时候用后缀数组水过了，时间复杂度是O(Qn+nlogn)；

先对整个串跑一遍后缀数组，然后对于每一次的询问，直接从SA数组里取出来，然后按照统计串中不同字串的论文题来做，需要注意一下不同之处，

当前字串要统计的个数不一定是减去前一个字串统计的数目，也许还要减去更前一个字串的个数；

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;
const int N = 2000+10;
struct Suffix_Array{
    int a1[N],a2[N],c[N],sa[N],SA[N],*x,*y,n,m;
    int height[N],*rank;
    void sort(){
        for (int i = 0; i < m ; i++) c[i] = 0;
        for (int i = 0; i < n; i++) c[x[i]] ++;
        for (int i = 0; i < m; i++) c[i+1] += c[i];
        for (int i = n-1; i>=0; i-- ) SA[--c[x[sa[i]]]] = sa[i];
    }
    void build_SA(char *s){
        n = strlen(s); m = 256;
        x = a1; y = a2; x[n] = y[n] = -1;
        for (int i = 0; i < n; i++) x[i] = s[i], sa[i] = i;
        sort();
        for (int k = 1; k <= n; k <<= 1){
            int p = 0;
            for (int i = n-k; i < n; i++) sa[p++] = i;
            for (int i = 0; i < n; i++) if (SA[i] >= k) sa[p++] = SA[i] - k;
            sort();
            
            p = 0; y[ SA[0] ] = 0;
            for (int i = 1; i < n; i++){
                if ( x[SA[i-1]] != x[SA[i]] || x[SA[i-1]+k]!= x[SA[i]+k] ) p++;
                y[SA[i]] = p;
            }
            swap(x,y);
            if (p+1 == n) break;
            m = p+1;
        }
        rank = x; getHeight(s);
    }
    void getHeight(char *s){
        int k = 0;
        for (int i = 0; i < n; i++){
            if (k) k--;
            if (rank[i] == 0) continue;
            int j = SA[rank[i] - 1];
            while (s[j+k] && s[i+k] == s[j+k]) k++;
            height[rank[i]] = k;
        }
        height[n] = 0;
    }
    
}H;
int f[12][N];
void initRMQ(int n,int height[]){
    n--;
    for  (int i = 1; i <= n; i++) f[0][i] = height[i];
    for (int j = 1; (1<<j) <= n; j++)
        for (int i = 1; i+(1<<(j-1)) <= n; i++){
            f[j][i] = min(f[j-1][i] ,f[j-1][i+(1<<(j-1))]);
        }
};
int lcp(int a,int b){
    if (a > b) swap(a,b);
    a++;
    int k = 0;
    while (1<<(1+k) <= b - a +1) k++;
    return min(f[k][a],f[k][b-(1<<k)+1]);    
}
char s[N];
int Q;
vector<int> q;
void solve(int l,int r){
    int n = strlen(s);
    q.clear();
    int cnt = r - l + 1;
    for (int i = 0; i <n; i++){
        if (H.SA[i]>=l && H.SA[i]<=r){
            q.push_back(i);
            cnt -- ;
        }
        if (cnt == 0) break;
    }
    int ret = r - H.SA[ q[0] ] + 1;
    int tmp = ret;
    for (int i = 1; i < q.size(); i++){
        int t1 = r - H.SA[ q[i-1] ] + 1;
        int t2 = r - H.SA[ q[i] ] + 1;
        int lc = lcp(q[i-1],q[i]);
        if (lc<tmp) tmp = lc;
        if (t2 - tmp > 0) ret += t2 - tmp;
        if (t2 > tmp) tmp = t2;
    }
    printf("%d
",ret);
}
int main(){
    //freopen("D:\in.txt","r",stdin);
    //freopen("D:\out.txt","w",stdout);
    int T; scanf("%d",&T);        
    while (T--){
        scanf("%s",s);
        scanf("%d",&Q);
        H.build_SA(s);
        //check();
        initRMQ(H.n,H.height);
        while (Q--){
            int l,r;
            scanf("%d%d",&l,&r);
            solve(l-1,r-1);
        }    
    }
    return 0;
}

hdu 4627

题意：给你一个数n,求a+b = n,lcm(a,b)最大;

分析：n为奇数，答案(n/2)*(n/2+1);

n为偶数，k = n/2;k是奇数，答案为k-2,k+2;否则k-1,k+1;比赛的时候直接暴力找了。

#include<cstring>
#include<cstdlib>
#include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
#include<cstdio>
using namespace std;
typedef long long LL;
const int N = 1000;
LL n;
void solve(){
    LL l ,r;
    if (n%2 == 0){
        l = r =n/2;
    }else {
        l = n/2; r = n/2+1;
    }
    LL ans = 0;
    while (1){
        LL t = __gcd(l,r);
        if (t==1){
            if (l*r>ans) ans = l*r;
            break;
        }else {
            if (l*r/t > ans) ans = l*r/t;
        }
        l--; r++;
        if (l == 0) break;
    }
    printf("%I64d
",ans);

}
int main(){
    int T; scanf("%d",&T);
    while (T--){
        scanf("%I64d",&n);
        solve();
    }
    return 0;
}

hdu 4628

题意：给你一个串，每次只能删除一个回文序列，求最少多少次能把这个串删完；

分析:n = 16，状压，预处理出所有是回文序列的情况，然后DP也过了，题解是一个3^n的方法，就是每次用位运算每次枚举I的子集；

这个是枚举i的子集的位运算写法：for (int j = i;  j ; j = i & (j-1));

然后为什么是3^n次，首先从0~1<<n里面含有一个1的个数是c(n,1),2个1的有c(n,2),...n个1的c(n,n);

含有一个1的数的子集有2^1,2个1的数的子集有2^2,k个1的数2^k,...然后加起来就是(2+1)^n == 3^n;

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<vector>
#include<cmath>
using namespace std;
const int N = 1<<16;
char s[20];
int n;
vector <int > q;
int check(int x){
    char ts[20];
    int c = 0;
    for (int i = 0; i < n; i++ ){
        if (x&(1<<i)) ts[c++] = s[i];  
        ts[c] = 0;
    }
    
    int k = 0,l , r;
    if (c%2){
        l = r = c/2;
    }else {
        l = c/2-1; r = c/2;
    }
    while (ts[l-k] == ts[r+k] && l-k>=0 && r+k<c){
        k++;
    }
    if (r+k == c) {
        return 1;
    }
    return 0;
}
int dp[N],can[N];
void init(){
    memset(can,0,sizeof(can));
    for (int i = 1; i < (1<<n); i++){
        if (check(i)){
            can[i] = 1;
        }
    }

}
void solve(){
    for (int i = 0; i < (1<<n); i++)  dp[i] = n;
    dp[0] = 0;
    for (int i = 1; i < (1<<n); i++){
        for (int j = i; j ; j = i&(j-1)){
            if (can[j])
            dp[i] = min(dp[i] , dp[i^j]+1); 
        }
    }
    printf("%d
",dp[(1<<n)-1]);
}
int main(){
    int T; scanf("%d",&T);
    while (T--){
        scanf("%s",s);
        n = strlen(s);
        init();
        solve();
    }
    return 0;
}

hdu 4630

题意：给你一个1~n的排序a1~an，Q次询问在区间[l,r]中的最大gcd(a,b).a,b属于[l,r];

分析：离线，从左到右扫一遍，idx[x]记录的是扫到当前位置时，含有x因子的最右的数的位置；

这样对于当前位置的ai,找出ai的所有约数，对于约数bi，在线段树中更新 在前面出现的含有bi的最右边的数的那个位置的值，也就是idx[bi]处更新出现的最大约数；

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
using namespace std;
const int N = 50000+10;
int mx[N<<2];
int idx[N];
int a[N];
int n,Q;
struct Line{
    int x,y;
    int id,ans;
    Line(){}
    Line (int x,int y):x(x),y(y){}
    bool operator < (const Line &p)const{
        return y<p.y || (y == p.y && x < p.x);
    }
}L[N];
bool cmp(Line a,Line b){
    return a.id<b.id;
}
void pushup(int rt){
    mx[rt] = max(mx[rt<<1] , mx[rt<<1|1]);
}

void update(int L,int c,int l,int r,int rt){
    if (l == r){
        if (c > mx[rt]) mx[rt] = c;
        return;
    }
    int m = (l+r)>>1;
    if (L <= m) update(L,c,lson);
    if (m <  L) update(L,c,rson);
    pushup(rt);
}
int query(int L,int R,int l,int r,int rt){
    if (L<=l && r<=R){
        return mx[rt];
    }
    int m = (l+r)>>1;
    int t1 = 0, t2 = 0;
    if (L <= m) t1 = query(L,R,lson);
    if (m <  R) t2 = query(L,R,rson);
    return max(t1,t2);
}
void insert(int now){
    int m = (int)sqrt((double)a[now]);
    
    for (int  j = 1; j <= m ; j++){        
        if (a[now]%j == 0){
            update(idx[j], j, 0, n, 1);
            idx[j] = now;
            if (a[now]/j !=j){
                int c = a[now] / j;
                update(idx[c], c, 0, n, 1);
                idx[c] = now;
            }
        }
    }    
}
void solve(){
    memset(mx,0,sizeof(mx));
    memset(idx,0,sizeof(idx));
    int now = 1,flag = 1;
    for (int i = 0; i < Q; ){
        
        if ( flag ){
            flag = 0; insert(now);
        }
        if (L[i].y == now){
            L[i].ans = query(L[i].x, L[i].y, 0, n, 1);
            i++;
        }
        if (now < L[i].y ){
            flag = 1; now++;
        }
    }
    sort(L,L+Q,cmp);

    for (int i = 0; i < Q; i++){
        printf("%d
",L[i].ans);
    }
}
int main(){
    int T; scanf("%d",&T);
    while (T--){
        scanf("%d",&n);
        for (int i = 1; i <= n; i++){
            scanf("%d",&a[i]);
        }
        scanf("%d",&Q);
        for (int i = 0; i < Q; i++){
            scanf("%d%d",&L[i].x,&L[i].y);
            L[i].id = i;
        }
        sort(L,L+Q);
        solve();
    }
    return 0;
}

hdu 4631

题意：依次给你n个点，每次求出当前点中的最近点对，输出所有最近点对的和；

分析：按照x排序，然后用set维护，每次插入只更新当前点和插入点前后几个位置，如果最近距离变为0就break；

因为点的坐标的构造方法，所以是可以过的，（其实我也不太懂）；

#include<iostream>
#include<algorithm>
#include<cmath>
#include<iostream>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<set>
using namespace std;
typedef long long LL;
const int N = 110000;
int n;
LL ax,bx,cx,ay,by,cy;
struct Point{
    LL x,y;
    Point(){}
    Point(LL x,LL y):x(x),y(y){};
    bool operator < (const Point &p)const{
        return x < p.x || (x == p.x && y < p.y);
    }
    void ot(){
        cout<<x<<" "<<y<<endl;
    }
};
LL sqr(LL x){
    return x*x;
}
LL Distance(Point a,Point b){
    return sqr((LL)a.x - b.x) + sqr((LL)a.y - b.y);
}
Point p[100];
multiset<Point> st;
multiset<Point> :: iterator it1,it2,it3;

void solve(){
    st.clear();
    LL ans = 0;
    LL nx = 0, ny = 0;
    nx = ( bx ) % cx;
    ny = ( by ) % cy;
    st.insert(Point(nx,ny));    
    LL mi = -1;
    for (int i = 1; i < n; i++){
        nx = ((LL)nx * ax + bx ) % cx;
        ny = ((LL)ny * ay + by ) % cy;
        Point t = Point(nx,ny);
        st.insert(t);
        it1 = it2 = it3 = st.lower_bound(t);
        int k = 10;
        while (k--){
            if (it1 != st.begin()) it1--;
            if (it3 != it1){
                LL d1 = Distance(t,*it1);
                if (mi == -1 || d1<mi){
                    mi = d1;
                }
            }
            if (it2 != st.end()) it2++;
            if (it2 != st.end() && it2!= it3){
                LL d2 = Distance(t,*it2);
                if (mi == -1 || d2 < mi){
                    mi = d2;
                }
            }
        }
        ans += mi;
        if (mi == 0) break;
    }
    printf("%I64d
",ans);
}
int main(){
    int T; scanf("%d",&T);
    while (T--){
        scanf("%d",&n);
        scanf("%d%d%d%d%d%d",&ax,&bx,&cx,&ay,&by,&cy);
        solve();
    }
    return 0;
}