hdu多校6

这个场要恶心死我了。。

1001

积分题，不要四舍五入

//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#define fi first
#define se second
#define db double
#define mp make_pair
#define pb push_back
#define pi acos(-1.0)
#define ll long long
#define vi vector<int>
#define mod 1000000007
#define ld long double
#define C 0.5772156649
#define ls l,m,rt<<1
#define rs m+1,r,rt<<1|1
#define pll pair<ll,ll>
#define pil pair<int,ll>
#define pli pair<ll,int>
#define pii pair<int,int>
//#define cd complex<double>
#define ull unsigned long long
#define base 1000000000000000000
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
#define fio ios::sync_with_stdio(false);cin.tie(0)
template<typename T>
inline T const& MAX(T const &a,T const &b){return a>b?a:b;}
template<typename T>
inline T const& MIN(T const &a,T const &b){return a<b?a:b;}
inline void add(ll &a,ll b){a+=b;if(a>=mod)a-=mod;}
inline void sub(ll &a,ll b){a-=b;if(a<)a+=mod;}
inline ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
inline ll qp(ll a,ll b){ll ans=;while(b){if(b&)ans=ans*a%mod;a=a*a%mod,b>>=;}return ans;}
inline ll qp(ll a,ll b,ll c){ll ans=;while(b){if(b&)ans=ans*a%c;a=a*a%c,b>>=;}return ans;}

using namespace std;

const double eps=1e-;
const ll INF=0x3f3f3f3f3f3f3f3f;
const int N=+,maxn=+,inf=0x3f3f3f3f;

int a,b;
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&a,&b);
        double ans=pi*a+2.0*b;
        ll ret = ans * ;
        printf("%.6f\n", 1.0 * ret / );
    }
    return ;
}
/********************

********************/

1012

物理题。。。。

#include<bits/stdc++.h>
using namespace std;
const int N = ;
const int mod = ;
double a, b, x, y;
int main() {
    int T; scanf("%d", &T);
    while(T--) {
        scanf("%lf%lf%lf%lf", &a, &b, &x, &y);
        a=fabs(a);
        b=fabs(b);
        x=fabs(x);
        y=fabs(y);
        double h = x * (b) / a;
        double val = b / sqrt(a * a + b * b);//sin

        double H=y-h;
        double t=sqrt(*9.8*H)/9.8;

        double hi=;
        for(int i = ;i <=; i++) {
            hi+=*i*9.8*t*t*val*val;
            if(hi>h){
                printf("%d\n",i);
                break;
            }
        }
    }

}

1009

村民永远无法确定，狼只能在只有一条狼边的环里确认，然后找出这些狼反推找其他狼。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define PII pair<int, int>
#define PLI pair<LL, int>
#define PLL pair<LL, LL>
#define y1 skldjfskldjg
#define y2 skldfjsklejg

using namespace std;

const int N = 1e5 + ;
const int M = 1e5 + ;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 +;
const double PI = acos(-);
const double eps = 1e-;

int to[N], n, a[N];
bool vis[N], is[N];
char s[];

vector<int> edge[N];
int deg[N];
int main() {
    int T; scanf("%d",&T);
    while(T--){
        memset(vis, , sizeof(vis));
        memset(deg, , sizeof(deg));
        memset(is, , sizeof(is));
        queue<int> que, Q;
        scanf("%d",&n);
        for(int i = ; i <= n; i++) edge[i].clear();
        for(int i = ; i <= n; i++) {
            scanf("%d%s", &to[i], s);
            if(s[] == 'w') {
                a[i] = ;
            } else {
                a[i] = ;
                edge[to[i]].push_back(i);
            }
            deg[to[i]]++;
        }

        for(int i = ; i <= n; i++) {
            if(!deg[i]) {
                is[i] = true;
                Q.push(i);
            }
        }

        while(!Q.empty()) {
            int u = Q.front(); Q.pop();
            int v = to[u];
            if(is[v]) continue;
            deg[v]--;
            if(!deg[v]) {
                Q.push(v);
                is[v] = true;
            }
        }

        for(int i = ; i <= n; i++) {
            if(is[i]) continue;
            int id = -, cnt = , now = i;
            while(!is[now]) {
                is[now] = true;
                if(a[now]) cnt++, id = to[now];
                now = to[now];
            }
            if(cnt == ) {
                vis[id] = true;
                que.push(id);
            }
        }

        while(!que.empty()) {
            int u = que.front(); que.pop();
            for(int i = ; i < edge[u].size(); i++) {
                int v = edge[u][i];
                if(vis[v]) continue;
                vis[v] = true;
                que.push(v);
            }
        }

        int ans = ;
        for(int i = ; i <= n; i++)
            if(vis[i]) ans++;
        printf("0 %d\n", ans);
    }
    return ;
}
/*
*/

补题****************************************************************************************

1002

我们首先要找出这两个性质。。。

gcd(2 ^ a - 1, 2 ^ b - 1) = gcd(2 ^ (gcd(a, b)) - 1)

gcd(fib[ i ], fib[ j ]) = f [gcd(i , j)]

http://bestcoder.hdu.edu.cn/blog/

题解说的很清楚啦

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define pii pair<int, int>
#define y1 skldjfskldjg
#define y2 skldfjsklejg

using namespace std;

const int N = 1e6 + ;
const int M = 1e5 + ;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 +;

int inv[N << ], f[N << ], finv[N << ], fib[N], bin[N], stk[N], a[N], n, k, tot;

int fastPow(int a, int b) {
    int ans = ;
    while(b) {
        if(b & ) ans = 1ll * ans * a % mod;
        a = 1ll * a * a % mod; b >>= ;
    }
    return ans;
}

void add(int &a, int b) {
    a += b; if(a >= mod) a -= mod;
}
void sub(int &a, int b) {
    a -= b; if(a < ) a += mod;
}

void init() {
    finv[] = f[] = inv[] = f[] = finv[] = fib[] = ;
    for(int i = ; i < N * ; i++) {
        inv[i] = 1ll * (mod - (mod / i)) * inv[mod % i] % mod;
    }
    for(int i = ; i < N * ; i++) {
        f[i] = 1ll * f[i - ] * i % mod;
        finv[i] = 1ll * finv[i - ] * inv[i] % mod;
    }
    for(int i = ; i < N; i++) fib[i] = (fib[i - ] + fib[i - ]) % (mod - );
}

int comb(int n, int m) {
    return 1ll * f[n] * finv[m] % mod * finv[n - m] % mod;
}

int main() {
    init();
    int T; scanf("%d", &T);
    while(T--) {
        memset(a, , sizeof(a)); tot = ;
        scanf("%d%d", &n, &k);

        int ans = ;
        for(int i = n; i >= ; i--) {
            if(n % i) continue;
            a[i] = comb(n / i + k - , k - );
            for(int j = i + i; j <= n; j += i)
                sub(a[i], a[j]);
            add(ans, 1ll * a[i] * (((fastPow(, fib[i]) -  + mod) % mod)) % mod);
        }
        ans = 1ll * ans * fastPow(comb(n + k - , k - ), mod - ) % mod;
        printf("%d\n", ans);
    }
    return ;
}

1004

区间dp，先把线段的两个端点用极坐标离散化一下，总共只有2*n个发射方向。

dp[ i ][ j ]表示把完全位于i, j之间的线段都射穿需要的代价，对于一个区间来说

然后枚举最大需要的能量发射的方向之后变成两个独立区间然后转移。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define pii pair<int, int>
#define y1 skldjfskldjg
#define y2 skldfjsklejg

using namespace std;

const int N =  + ;
const int M = 1e5 + ;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 +;

int n, tot;
LL f[N][N];
struct Point {
    LL x, y;
    Point(LL x = , LL y = ) : x(x), y(y) { }
} hs[N];
LL cross(const Point &a, const Point &b) {
    return a.x * b.y - a.y * b.x;
}
bool operator < (const Point &A, const Point &B) {return cross(A, B) < ;}
bool operator == (const Point &A, const Point &B) {return cross(A, B) == ;}
struct Line {
    Point L, R;
    int w, l, r;
} a[N];
LL dp(int i, int j) {
    if(i >= j) return ;
    if(f[i][j] != -) return f[i][j];
    int mx = -;
    for(int k = ; k <= n; k++)
        if(a[k].l >= i && a[k].r <= j && a[k].w > mx)
            mx = a[k].w;
    if(mx == -) return f[i][j] = ;
    f[i][j] = INF;
    for(int k = i; k <= j; k++) f[i][j] = min(f[i][j], dp(i, k - ) + dp(k + , j) + mx);
    return f[i][j];
}

int main() {
    int T; scanf("%d", &T);
    while(T--) {
        memset(f, -, sizeof(f)); tot = ;
        scanf("%d", &n);
        for(int i = ; i <= n; i++) {
            LL h, l, r, w;
            scanf("%lld%lld%lld%lld", &h, &l, &r, &w);
            a[i].L = Point(l, h); a[i].R = Point(r, h); a[i].w = w;
            hs[++tot] = a[i].L; hs[++tot] = a[i].R;
        }
        sort(hs + , hs +  + tot);
        tot = unique(hs + , hs +  + tot) - hs - ;
        for(int i = ; i <= n; i++) {
            a[i].l = lower_bound(hs + , hs +  + tot, a[i].L) - hs;
            a[i].r = lower_bound(hs + , hs +  + tot, a[i].R) - hs;
        }
        printf("%lld\n", dp(, tot));
    }
    return ;
}

/*
*/