20140705 总结

说好的的赛区难度... →_→ “不完全是赛区难度”==“完全不是赛区难度”

看完了题做好了爆0的准备，从testC开始写，结果有30，正解是dp...

testB我是在最后十分钟才写的，感觉像最长公共子序列，但是时间不够了，我就直接printf("%d ", s/e);结果有80...

testA写了个Floyd，然后就开始乱搞了，结果就wa0...

 -----------------------------------------------------------------------------

testA

输入文件: testA.in  输出文件: testA.out 时限: 2000ms

 

问题描述：

         有一个城市拥有N个节点，被M条有权无向路径连接。现在你要在一个地方(可以在路径上当然也可以在节点上)开设一家咖啡馆，使得所有节点达到这个咖啡馆的最短路里面最大值最小（也就是说离咖啡馆最远的节点距离尽可能得小），求出这个最大值的最小值。

 

输入描述：

第一行N和M。

第2至M+1行，每行三个整数U,V,W。表示从U到V有一条权值为W的无向边。

 

输出描述：

一行一个数表示答案。 四舍五入至2位小数

数据范围 N<=200 , W<=100000 , M<=19900

 

样例输入：

3 2
1 2 100
2 3 1

 

样例输出：

50.50

 

题解:

二分答案L

对于一个L，枚举每一条边(x, y, w)，只要有一条边符合情况，L合法

对于一条边，枚举每一个点k：(1)dis[x][k]>L && dis[y][k]>L ->这条边不和发

　　　　　　　　　　　　　  l = L-dis[x][k], r = L-dis[y][k]

 　　　　　　　　　　　　　(2) l>=w || r>=w || r+l>=w ->这个点对于这条边合法

　　　　　　　　　　　　　 (3) 求一个区间， 既对于点k在这条直线上标出不合法的安放区间

                                        -> 求并集U：

　　　　　　　　　　　　　　　　　  　 若U==[0,w]->此边不合法

　　　　　　　　　　　　　　　　　　　else ->合法　　　

#define NOMBRE "testA"
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

const int INF = 0x3f3f3f3f;
const int MAXN = 200+10;

double Pri;
int N, M, dis[MAXN][MAXN];

struct Edge{
    int to, d;
};

vector< pair<int, int> > cj;
vector<Edge> e[MAXN];

inline Edge MakeEdge(int to, int d){
    Edge ret;
    ret.to = to, ret.d = d;
    return ret;
}

inline void Floyd(){
    for (int i=1; i<=N; i++)
        dis[i][i] = 0;
    for (int k=1; k<=N; k++)
        for (int i=1; i<=N; i++){
            if (dis[i][k]==INF) continue;
            for (int j=1; j<=N; j++)
                dis[i][j] = min(dis[i][j], dis[i][k]+dis[k][j]);

        }
}

inline bool OkayEdge(int L, int x, int y, int w){
    int dl, dr, Tail = 0, CJs;
    cj.clear();
    for (int k=1; k<=N; k++){
        dl = L-dis[x][k], dr = L-dis[y][k];
        if (dl<0 && dr<0) return false;
        if (dl>=w || dr>=w || dl+dr>=w) continue;
        cj.push_back(make_pair(dl+1, w-dr-1));
    }
    if (cj.empty()) return true;
    sort(cj.begin(), cj.end());
    CJs = cj.size();
    for (int i=0; i<CJs; i++){
        if (Tail<cj[i].first) return true;
        if (Tail<cj[i].second+1) Tail = cj[i].second+1;
    }
    return false;
}

inline bool Okay(int L){
    int Es;
    for (int i=1; i<=N; i++){
        Es = e[i].size();
        for (int j=0; j<Es; j++)
            if (OkayEdge(L, i, e[i][j].to, e[i][j].d)) return true;
    }
    return false;
}

int main(){
    freopen(NOMBRE ".in", "r", stdin);
    freopen(NOMBRE ".out", "w", stdout);

    memset(dis, 0x3f, sizeof(dis));
    scanf("%d %d", &N, &M);
    int u, v, d;
    for (int i=0; i<M; i++)
        scanf("%d %d %d", &u, &v, &d),
        d <<= 1, e[u].push_back(MakeEdge(v, d)),
        dis[u][v] = dis[v][u] = min(dis[u][v], d);
    Floyd();
    int l = 0, r = INF, Mid;
    while (l<=r){
        Mid = (l+r)>>1;
        if (Okay(Mid)) r = Mid-1, Pri = Mid;
        else l = Mid+1;
    }
    printf("%.2lf", Pri/=2.0);
}

 

 -----------------------------------------------------------------------------

testB

输入文件: testB.in  输出文件testB.out 时限2000ms

 

问题描述：

方师傅有两个由数字组成的串 a1,a2,⋯,an 和 b1,b2,⋯,bm。 有一天，方师傅感到十分

无聊因此他决定用这两个串来玩玩游戏。游戏规则十分简单，方师傅会进行一些操作，每个操作可能是以下两种操作之一：

 

1.从a串选择一个a的非空前缀，再从b串选一个b的非空前缀。这两个前缀的最后一个元素必须相等，完成选择后把这两个前缀删除。

 

2.删除两个串所有的元素。

 

第一种操作会耗费e的能量值，并为方师傅增加一美分到他的电子账户中。第二种操作会耗费两个串的不完整度的能量。不完整度 = 两个串已经被删除的元素的数目。只有执行第二种操作后，方师傅才能从电子帐户中取出他的钱。 

刚开始时，方师傅有一个空的电子账户和s的能量，请问方师傅最多可以赚多少美分？注意，由于乐警官偷吃光了方师傅的士力架，导致方师傅无法补充能量，因此方师傅的能量任何时候都不能小于0。

 

输入描述： 

第一行4个整数，n,m,s,e(1≤n,m≤10^5;1≤s≤3×10^5;10^3≤e≤10^4)。

第二行n个整数，a1,a2⋯an.

第三行m个整数，b1,b2⋯bm.

1≤ai,bi≤10^5

 

输出描述：

输出一个整数，方师傅可以最多赚得的美分数目。

 

样例输入1：

5 5 100000 1000

1 2 3 4 5

3 2 4 5 1

 

样例输出1：

3

样例输入2：

3 4 3006 1000

1 2 3

1 2 4 3

 

样例输出2：

2

 

dp[i][j]表示A匹配到i位置获得j美分是匹配到B的位置

 //看来标程才想到vector...多么美好vector啊

#define NOMBRE "testB"
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 1e5+10;
const int MAXJ = 300+10;

int n, m, s, e, x, Best, Pri, a[MAXN], b[MAXN], dp[MAXN][MAXJ];
vector<int> v[MAXN];

int main(){
    freopen(NOMBRE ".in", "r", stdin);
    freopen(NOMBRE ".out", "w", stdout);

    memset(dp, 0x3f, sizeof(dp));
    scanf("%d %d %d %d", &n, &m, &s, &e), Best = s/e;
    for (int i=1; i<=n; i++)
        scanf("%d", &a[i]);
    for (int i=1; i<=m; i++)
        scanf("%d", &b[i]),
        v[b[i]].push_back(i);
    
    int temp;
    dp[0][0] = 0;
    for (int i=1; i<=n; i++){
        dp[i][0] = 0;
        for (int j=0; j<=Best; j++){
            dp[i][j] = dp[i-1][j];
            x = upper_bound(v[a[i]].begin(), v[a[i]].end(), dp[i-1][j-1])-v[a[i]].begin();
            temp = v[a[i]].size();
            if (x<temp) dp[i][j] = min(dp[i][j], v[a[i]][x]);
            if (j>Pri && i+dp[i][j]+j*e<=s) Pri = j; 
        }
    }    
    printf("%d
", Pri);
}

 

-----------------------------------------------------------------------------

testC 

输入文件: testC.in  输出文件testC.out 时限1000ms 

 

问题描述：

给你一组数，a₁, a₂, a3,⋯,a_n。令：G=gcd(a₁, a₂, a3,⋯,a_n)。

现在从中任意删除一些数字，设剩下的数为：a₁, a₂, a3,⋯,a_m。再令：g=gcd(a₁, a₂, a3,⋯,a_m)

现要求G=g，问最多能删除多少数？

 

输入描述：

第一行一个数n，第二行n个数a1,a2,a3,⋯,an。

1≤n≤700

1≤ai≤10000

 

输出描述：

输出只有一个数，表示最多能删除多少数。

 

样例输入：

3

4 6 8

样例输出

1

 

题解：

dp[i]表示使得gcd为i最少使用多少数

#define NOMBRE "testc"
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 10000; 
const int MAXN = 700+10;

int n, g, dp[N+10], a[MAXN], max;

int gcd(int a, int b){
    if (!a && b) return b;
    if (!b && a) return a;
    while (b^=a^=b^=a%=b);
    return a;
}

int main(){
    freopen(NOMBRE ".in", "r", stdin);
    freopen(NOMBRE ".out", "w", stdout);

    memset(dp, 0x3f, sizeof(dp));
    scanf("%d", &n), dp[0] = Max = g = 0;
    for (int i=0; i<n; i++)
        scanf("%d", &a[i]), g = gcd(g, a[i]), Max = max(Max, a[i]);
    for (int i=0; i<n; i++)
        for (int j=0; j<=Max; j++)
            dp[gcd(a[i], j)] = min(dp[gcd(a[i], j)], dp[j]+1);
    printf("%d
", n-dp[g]);
}