2013多校第七场

hdu 4666

题意：n个事件，op == 0 插入一个点，op == 1删除一个点，每个事件之后询问当前点里曼哈顿距离最大的值；

分析：曼哈顿距离等于abs(a.x - b.x) + abs(a.y - b.y);

就是c1*(a.x- b.x) + c2*(a.y - b.y)，c1,c2取1或-1；显然只有当c1,c2去恰当值后值才是他们的曼哈顿距离，并且是最大的；

这样我们就有思路了，开1<<k个multiset，对于每个点都放入不同的multiset里，而在同一个muliset里，直接相减就是最大值；

其实就是高中的去绝对值的问题； 唉...

it1 = st.lower_bound(key); 注意st.erase(it1) 和st.erase(*it1)的区别;

#include<iostream>
#include<algorithm>
#include<vector>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<set>
#include<map>
using namespace std;
const int N = 1<<5;
int n,k;
struct node{
    int a[5];
    int s;
    void init(){
        memset(a,0,sizeof(a));
    }
    void sum(){
        s = 0;
        for (int i = 0; i < 5; i++) s += a[i];
    }
    bool operator < (const node &p) const{
        return s < p.s;
    }
}nd[60000+10];

multiset<node> st[N];
multiset<node> :: iterator it1,it2;
void print(){
    int ans = 0;
    for (int i = 0; i <(1<<k); i++) {
        it1 = st[i].begin();
        if (it1 == st[i].end()) continue;
        it2 = st[i].end();
        it2 --;
        if (it2->s - it1->s > ans) ans = it2->s - it1->s;
    }
    printf("%d
",ans);

}
int main(){

    while (~scanf("%d%d",&n,&k)) {
        for (int i = 0; i < (1<<k) ; i++) st[i].clear();
        node t1,t2;
        for (int w = 0; w < n; w++) {
            int op; scanf("%d",&op);
            if (op == 0) {
                t1.init();
                for (int i = 0; i < k; i++) {
                    scanf("%d",&t1.a[i]);
                }
                nd[w+1] = t1;
                t2.init();
                for (int i = 0; i < (1<<k); i++) {
                    for (int j = 0; j < k; j++) {
                        if (i & (1<<j)) {
                            t2.a[j] = -t1.a[j];
                        }else t2.a[j] = t1.a[j];
                    }
                    t2.sum();
                    st[i].insert(t2);
                }
                print();
            }else {
                int d; scanf("%d",&d);
                t2.init();
                for (int i = 0; i < (1<<k); i++) {

                    for (int j = 0; j < k; j++) {
                        if (i & (1<<j)) {
                            t2.a[j] = -nd[d].a[j];
                        }else t2.a[j] = nd[d].a[j];
                    }
                    t2.sum();
                    it1 = st[i].lower_bound(t2);
                    st[i].erase(it1);
                }
                print();
            }
        }
    }

    return 0;
}

hdu 4667

题意：给你n个圆和m个三角形，求最短的绳子把他们包围起来。

分析：取出所有点与所有圆的切线的切点和两两圆的公切线的切点，和三角形的点一起求凸包；

然后相邻的点判断是否在同一个圆上，如果是就要求弧长，不然就是两点之间距离；

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#define pbk push_back
using namespace std;

const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxP = 40000+10;
inline int dcmp(double x){
    return x<-eps ? -1 : x>eps;
}
inline double sqr(double x){
    return x*x;
}
struct Point {
    double x,y;
    Point(){}
    Point (double a,double b):x(a),y(b){}
    bool operator == (const Point &p)const{
        return (dcmp(x-p.x) == 0 && dcmp(y-p.y) == 0);
    }
    bool operator < (const Point &p)const{
        return dcmp(x-p.x) < 0 || (dcmp(x-p.x) == 0 && dcmp(y-p.y) < 0);
    }
    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;
    }

    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 len2(){
        return x*x + y*y;
    }
    double len(){
        return sqrt(x*x + y*y);
    }
    Point scale(const double &k){//变成长度为k的"向量"
        return dcmp( len() ) ? (*this) * (k / len()) : (*this);
    }
    Point turnLeft(){
        return Point(-y,x);
    }
    Point turnRight(){
        return Point(y,-x);
    }
    void input(){
        scanf("%lf%lf",&x,&y);
    }
    void ot(){
        printf("%lf %lf
",x,y);
    }
    double Distance(const Point &p){
        return sqrt( sqr(x-p.x) + sqr(y-p.y) );
    }
};

struct Polygon{
    int n;
    Point p[maxP];
    void input(){
        for (int i = 0; i < n; i++){
            p[i].input();
        }
    }
    void push(const Point &pp){
        p[n++] = pp;
    }

    void getConvex(Polygon &c){
        sort(p, p+n);
        c.n = n;
        if (n == 0) return;
        c.p[0] = p[0]; if (n == 1) return;
        c.p[1] = p[1]; if (n == 2) return;
        int &top = c.n;
        top =1;
        for (int i = 2; i < n; i++){
            while (top > 0 && dcmp( (c.p[top] - p[i])*(c.p[top-1] - p[i]) ) >= 0)
                top --;
            c.p[++top] = p[i];
        }
        int tmp = top;
        c.p[++top] = p[n-2];
        for (int i = n-3; i >= 0; i--){
            while (top > tmp && dcmp( (c.p[top] - p[i])*(c.p[top-1] - p[i]) ) >= 0)
                top --;
            c.p[++top] = p[i];
        }
    }

};
struct Circle{
    Point c;
    double r;
    Circle(){}
    Circle(const Point &a,const double &d):c(a),r(d){}
    bool operator == (const Circle &C)const{
        if (c == C.c && dcmp(r - C.r) == 0) return 1;
        return 0;
    }
    Point getPoint(double a) {
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
    int CrossCircle(const Circle &C) {//0包含，1相交，2相离
        double d = c.Distance(C.c);
        if ( dcmp( r + C.r - d ) < 0 ) return 2;
        if ( dcmp( d - fabs(r - C.r) ) < 0 ) return 0;
        return 1;
    }
    void CrossCirclePoint(const Circle &C, Point &p1, Point &p2) {
        double d = c.Distance(C.c);
        double d1 = ( sqr(d) + sqr(r) - sqr(C.r) ) / (2 * d);
        double h = sqrt(sqr(r) - sqr(d1));
        Point p = c + ( C.c - c ).scale(d1);
        Point vec = ( C.c - c ).turnLeft().scale(h);
        p1 = p - vec, p2 = p + vec;
    }
  
    void TangencyPoint(Point p,Point &p1,Point &p2) {//过圆外一点p的切线的切点p1,p2;
        Point q = c + ( p -c ).scale(r);
        double d = p.Distance(c);
        double d1 = sqrt(sqr(d) - sqr(r));
        Point vec = q - c;
        double Cos = r / d, Sin = d1 / d;
        p1 = c + Point(vec.x * Cos - vec.y * Sin, vec.y * Cos + vec.x * Sin);
        p2 = c + Point(vec.x * Cos + vec.y * Sin, vec.y * Cos - vec.x * Sin);
    }

 
    double arc(const Point &a, const Point &b) {//a到b的有向弧长
        double cp = ( a - c) * ( b - c );
        double ret = atan2(fabs(cp), ( a - c ) / ( b - c ));
        return cp > -eps ? ret*r : (2*PI - ret)*r;
    }
  
};
int n,m;
vector<Circle> ci;
vector<Point> pi;
Polygon H1,H2;
Point a[11],b[11];


//返回切线条数，a[i],b[i]分别表示第i条切线在A,B上的切点
int getTangents(Circle A, Circle B,Point a[],Point b[]) {
    int cnt = 0;
    if (dcmp( A.r - B.r ) < 0) {
        swap(A,B); swap(a,b);
    }
    double d = (A.c - B.c).len2();
    double rdiff = A.r - B.r;
    double rsum = A.r + B.r;
    if (d < sqr(rdiff)) return 0; //内含；
    if (dcmp(d) == 0 && dcmp(A.r - B.r) == 0) return -1;//两圆相同

    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);

    if (dcmp(d - sqr(rdiff)) == 0) { //内切,1条切线
        a[cnt] = A.getPoint(base); b[cnt++] = B.getPoint(base);
        return 1;
    }
    //有外公切线；
    double ang = acos( (A.r - B.r) / sqrt(d) );

    a[cnt] = A.getPoint(base+ang); b[cnt++] = B.getPoint(base+ang);
    a[cnt] = A.getPoint(base-ang); b[cnt++] = B.getPoint(base-ang);
    if (dcmp(d - sqr(rsum)) == 0) { //一条内公切线
        a[cnt] = A.getPoint(base);
        b[cnt++] = B.getPoint(PI+base);
    }else if (dcmp(d - sqr(rsum)) > 0) { //两条内公切线
        double ang = acos( (A.r + B.r) / sqrt(d) );
        a[cnt] = A.getPoint(base+ang); b[cnt++] = B.getPoint(PI+base+ang);
        a[cnt] = A.getPoint(base-ang); b[cnt++] = B.getPoint(PI+base-ang);
    }
    return cnt;
}

void init() {
    H1.n = 0;
    for (int i = 0; i < pi.size(); i++) {
        H1.push(pi[i]);
        for (int j = 0; j < ci.size(); j++) {
            if ( dcmp( pi[i].Distance(ci[j].c) - ci[j].r ) == 0 ) continue;
            Point t1,t2;
            ci[j].TangencyPoint(pi[i],t1,t2);
            H1.push(t1); H1.push(t2);
        }
    }
    for (int i = 0; i < ci.size(); i++) {
        double x = ci[i].c.x, y = ci[i].c.y, r = ci[i].r;
        H1.push(Point(x-r,y));
        H1.push(Point(x+r,y));
        H1.push(Point(x,y-r));
        H1.push(Point(x,y+r));//输入只有一个圆的情况
        for (int  j = i+1; j < ci.size(); j++) {
            int cnt = getTangents(ci[i],ci[j],a,b);
            for (int k = 0; k < cnt; k++) {
                H1.push(a[k]); H1.push(b[k]);
            }
        }
    }
}
int InCircle(Point a,Point b,double &len) {
    for (int i = 0; i < ci.size(); i++ ) {
        double d1 = a.Distance(ci[i].c);
        double d2 = b.Distance(ci[i].c);
        if (dcmp(d1 - ci[i].r) == 0 && dcmp(d2 - ci[i].r) == 0) {
            len = ci[i].arc(a,b);
           // if (dcmp(len) < 0) len = 2 * PI * ci[i].r + len;
            return 1;
        }
    }
    return 0;
}
void solve(){
    init();
    H1.getConvex(H2);
    double ret = 0;
    H2.p[H2.n] = H2.p[0];
    for (int i = 0 ; i < H2.n; i++) {
        double len = 0;
        if (InCircle(H2.p[i],H2.p[i+1],len)) {
            ret += len;
        }else ret += H2.p[i].Distance(H2.p[i+1]);
    }
    printf("%.10lf
",ret);
}
int main(){
    while (~scanf("%d%d",&n,&m)){
        ci.clear(); pi.clear();
        for (int i = 0; i < n; i++) {
            Point t; double r;
            t.input(); scanf("%lf",&r);
            ci.push_back(Circle(t,r));
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < 3; j++) {
                Point t; t.input();
                pi.push_back(t);
            }
        }
        solve();
    }
    return 0;
}

hdu 4675

题意：求和序列a只有k个不同的序列b，且gcd(b1,b2,...bn) = d的个数；

分析： 先求出公约数是b的序列的个数ans2[b]，那么对于gcd() = i;的个数就是

ans[i] = ans2[i] - ans[i*j]  (j>1);从m往1推；

当时只想到一个n^3的DP，唉...

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<vector>
#include<set>
using namespace std;
typedef long long LL;
const int N = 300000+10;
const int Mod = 1000000007;
int a[N];
int n,m,k;
int num[N];
LL c[N];
void ex_gcd(LL a, LL b, LL &g, LL &x, LL &y) {
    if ( b == 0 ) {
        g = a; x = 1; y = 0;
    }else {
        ex_gcd(b, a%b, g, y, x);
        y -= x * (a/b);
    }
}
LL MOD(LL x, LL n) {
    return (x % n + n) % n;
}
LL inv(LL a, LL n) {
    LL x,y,g;
    ex_gcd(a,n,g,x,y);
    return g == 1 ?  MOD(x,n) : -1;
}
LL pow_mod(LL a, LL k, LL p) {
    LL ret = 1, tmp = a % p;
    for (; k; k >>= 1) {
        if (k & 1) ret = ret * tmp % p;
        tmp = tmp *tmp % p;
    }
    return ret;
}

void init(){
    memset(num,0,sizeof(num));
    for (int i = 1; i <= n; i++) {
        num[a[i]]++;
    }
    int e = n - k;
    c[e] = 1;
    for (int i = e+1; i <= n; i++) {
        c[i] = c[i-1] * i % Mod * inv(i - e, Mod) % Mod;
    }
}
LL ans[N];
void solve(){
    init();
    memset(ans, 0, sizeof(ans));
    int e = n - k;
    for (int i = m; i >= 1; i--) {
        int cnt = 0;
        LL s = 0;
        for (int j = 1; j * i <= m; j++) {
            cnt += num[j * i];
            if (j > 1) s += ans[j * i];
        }
        if (cnt >= e) {
            ans[i] = c[cnt] * pow_mod( m/i-1, cnt-e, Mod) % Mod * pow_mod(m/i, n-cnt, Mod) % Mod;
            ans[i] = MOD(ans[i] - s, Mod);
        }
    }
    for (int i = 1; i <= m; i++) {
        printf("%I64d%c",ans[i],i == m ? '
' : ' ');
    }
}
int main(){

    while (~scanf("%d%d%d",&n,&m,&k)) {
        for (int i = 1; i <= n; i++) {
            scanf("%d",a+i);
        }
        solve();
    }
    return 0;
}

 hdu 4669

题意：给一个循环的序列，求子序列组成的数字mod K == 0 的个数；

分析：n*k的DP；

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstdlib>
#include<cmath>
using namespace std;
typedef long long LL;
const int N = 50000+10;
int n,k;
int a[N];
int dp[2][250];
int p[N],b[N*5];
void init(){
    for (int i = 1; i <= n; i++) {
        int t = a[i];
        int c = 0;
        while (t) {
            t /= 10;
            c++;
        }
        p[i] = c;
    }
    b[0] = 1;
    for (int i = 1; i <= n*5; i++) {
        b[i] = b[i-1]*10%k;
    }
}
void solve(){
    memset(dp,0,sizeof(dp));
    int pos = 0;
    LL ret = 0;
    init();
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < k; j++) {
            dp[pos^1][(j*b[p[i]]+a[i])%k] += dp[pos][j];
        }
        memset(dp[pos],0,sizeof(dp[pos]));
        dp[pos^1][a[i]%k] += 1;
        pos ^= 1;
    }
    int sum = 0;
    int tp = 0;
    for (int i = 1; i <= n; i++) {
        sum = (sum*b[p[i]] + a[i]) % k;
        tp += p[i];
    }
    for (int i = 1; i <= n; i++) {
        dp[pos][sum]--;
        for (int j= 0; j < k; j++) {
            dp[pos^1][(j*b[p[i]]+a[i])%k] += dp[pos][j];
        }
        memset(dp[pos],0,sizeof(dp[pos]));
        dp[pos^1][a[i]%k] += 1;
        ret += dp[pos^1][0] ;
        pos ^= 1;
        sum = (sum - a[i]*b[tp - p[i]]%k + k) % k;
        sum = (sum * b[p[i]] + a[i]) % k;
    }
    printf("%I64d
",ret);

}
int main(){
    while (~scanf("%d%d",&n,&k)) {
        for (int i = 1; i <= n; i++) {
            scanf("%d",a+i);
        }
        solve();
    }

    return 0;
}

hdu 4671

题意：n个服务器m个数据库，每个数据库都有一个服务器的优先级，如果当前服务器没有broken，那么当前数据库就在当前服务器上工作，问任意一个服务器崩溃后是否平衡，

平衡的定义是相邻两个服务器上工作的数据库个数差的绝对值小于等于1.

分析：对于n < m 的情况，每次枚举i服务器奔溃后，决定原先分配给该服务器的数据库的去向，按照少先的的原则，直接for；

其他情况都有固定解；

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<set>
using namespace std;
const int N = 100+10;
int n,m;
int a[N][N];
int cnt[N],cnt2[N];
void fillall(int x) {
    bool vis[N];
    memset(vis,0,sizeof(vis));
    vis[a[x][0]] = vis[a[x][1]] = 1;
    int i = 2, j;
    for (j = 1; j <= n; j++) {
        if (vis[j] == 0) {
            vis[j] = 1;
            a[x][i++] = j;
        }
    }
}
int main(){
    while (~scanf("%d%d",&n,&m)) {
        if (n > m) {
            int c = 1;
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < m; j++) {
                    a[j][i] = c++;
                    if (i == 1) a[j][i] = m+1;
                    if (c == n+1) c = 1;
                }
            }
        }else if (n == m) {
            for (int i = 0; i < 2; i++) {
                int c = i+1;
                for (int j = 0; j < m; j++) {
                    a[j][i] = c++;
                    if (c == n+1) c = 1;
                }
            }
        }else if (n < m) {
            memset(a, 0, sizeof(a));
            memset(cnt, 0, sizeof(cnt));
            int c = 1;
            for (int j = 0; j < m; j++) {
                cnt[c] ++;
                a[j][0] = c++;
                if (c == n+1) c = 1;
            }
            for (int j = 1; j <= m; j++) {
                for (int k = 1; k <= n; k++) {
                    cnt2[k] = cnt[k];
                }
                for (int i = 0; i < cnt[j]; i++) {
                    int d = -1;
                    for (int k = 1; k <= n; k++) if (k != j){
                        if (d == -1 || cnt2[k] < cnt2[d]) d = k;
                    }
                    for (int k = 0; k < m; k++) {
                        if (a[k][0] == j && a[k][1] == 0) {
                            a[k][1] = d;
                            cnt2[d]++;
                            break;
                        }
                    }
                }
            }
        }
        for (int i = 0; i < m; i++) fillall(i);
        for (int i = 0; i < m; i++) {
            for (int j =0; j < n; j++) {
                printf("%d%c",a[i][j],j == n-1 ? '
' : ' ');
            }
        }

    }

    return 0;
}