2008年成都网络赛训练总结

最新推荐文章于 2024-06-08 15:06:06 发布
最新推荐文章于 2024-06-08 15:06:06 发布
阅读量773 收藏
点赞数
分类专栏： 全部博客 ACM_解题报告|总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshi250hua/article/details/7796372
版权

     本次训练赛由我、DTen和sssplk完成，三台机子同时进行。

     本次训练我们发挥得并不好，只A了一题，但是第一题是很快的1A.然后我就开始卡题，4个小时半卡在B题-矩阵乘法，而DTen则对剩下的题目不知所措，sssplk负责几何也对那道几何无可奈何。这场比赛我能做的题比较多，但是因为坑爹的杭电只提供十分渺小的系统栈，导致我的矩阵二分时递归RE,，然后找各种模板来取代递归版，咳，都是RE.

     

     赛后我一共A了7道题，一道几何比较简单但没去敲，现在说下这场比赛的题目：

      2428、Stars   水题。因为是正方形，那么枚举两点，如果它们同线，另外两点的坐标也确定了。用hash来存坐标，然后直接判定那两点是否存在就好，秒杀之。

      2429、Word Game  矩阵乘法，给定n个串，当某串的末尾字符等于其他串的首字符时表示他们可以相连，用这些串可以组成一个表示是否能相连的矩阵，也是一个有向图。然后问走不大于n步并且步数为奇数后是目标T串的总方法数。设矩阵是A,那么我们求的就是A^1 + A^3 + ...A^n，再转换变成A1+A1 *( (A^2)^1 + (A^2)^2...(A^2)^k)，然后跑矩阵乘法n…n^3log（k）的复杂度解决。杭电改版后系统栈特别小，这题不能用递归式算法，并未那个k特别大。详细解题报告见Here.

      2430、Beans   很多方法都可以过，我用单调队列做。有n坨豌豆，每坨都有w[i]个，现在要从中选择连续的若干坨，然后用一个能装p个豌豆的背包装豆子，直到剩下的豌豆数量<=p为止，还要求剩下的豌豆数量少于k，问最多能装多少包。那么选择连续的一段和为sum，使得max(sum/p) 且sum%p<=k，这个sum可以用sum[i] - sum[j]来表示，那么确定了i，就是找最小的j使得(sum[i] - sum[j]) % p <= k,这时和最大。将每个和对p取余得到一个余数r数组，然后按余数大小优先位置其次的顺序排序。排完序之后就可以根据ri - k <= rj <= ri来往前找那个最小的j。遍历数组r，因为r是有序的，我用单调队列储存r小于当前的最小下标。详细解题报告见Here

      2431、Counting Problem  很难转换模型，但是转换后就是水题，训练没做出来，智商是硬伤啊。每次固定左上方边长为n-2，n-3...n-k的子正方形(n-k >= k)，剩下边长为2,3....k的子正方形随意放，设答案是dp[n]，dp[n] = dp[n-2] + dp[n-3] +..dp[n-k] (n-k<=k).这式子看起来不好写，但实际上用两个for循环就可以，第一位表示这个k，然后每次都加上dp[j-i]。具体见代码。


     2432、Farey Sequence Again  数论。第一次听到这种法雷级数，算见了市面。因为k<n这个条件的约束使得本题特别简单，因为小于n个的话分子要么是1，要么是2，要么是3，为什么，打表打几个看下然后YY即可得。得到上面的yy结论后，用O（1）的复杂度判断到底第k个法雷级数分子是1还是2还是3，n个可以分成1/2，1/3，以及剩下来的，1/2并不是严格的，而是(1+n) / 2,1/3是（n+2）/3，也就是上取整。第1部分分子是1，第2部分分子是2，第3部分比较难想，有1有2有3，那么将分子搞成6的话分母又是连续的，每6个连续的分母里面有2个是和6互质，那么就有4个分母可以进行约分。这样就找第几个4以及判断是4个中的第几个即可。

     2433、Travel  很好的搜索题。给定n个点m条边的无向连通图，Sum表示每个点到其他所有点的最小距离和，问我们删去某条边之后的Sum。朴素做法是枚举每条边，然后进行n次BFS，复杂度是O（n*m^2)。这个复杂度太高了，我们为了降低复杂度把枚举边转换成和点相关的操作，那么复杂度就有可能是O(n^2*m)，这样就应该能过。我们先预处理，做n次BFS,把每个点到其他所有点的最短距离求出来，并求出都经过哪些边，叫它关键边，如果某条边是这点的关键边，那么就要更新一次，再做一次BFS,否则直接用之前预处理求出的Sum即可。本题很值得学习的是这个预处理，我觉得和炮兵阵地的预处理一样漂亮，极大地降低了复杂度。

     2437、Jerboas 拓朴排序+DP,好题。给定一个n个点m条边的有向无环图，每个点表示一个洞，洞有临时和永久之分，从临时洞开始找一个永久洞结束，要求距离为k的倍数并要求距离最小。也就是说我们要找一个点，他的距离对k取模余数为0并且除数最小，这样到每个点最多1000种状态，我们设个Dp[i][j]，表示到i点状态j时对k的最小除数dp[i][j]*k+j就是最小距离。这样状态转移方程就是: Dp[next][j+(j+len)%k] = min(Dp[next][j+(j+len)%k],Dp[i][j]+(j+len)/k）（i有边连向next，边权为len),复杂度是O(n*m)

    

     本次训练状态确实不好，很多题目并不难，看到那些约束条件就可以轻松地转换模型，然后就可以做了。卡题卡得死死的，悲剧了...下不为例，一题最多卡1个半小时。

     这次比赛还是学到挺多东西，比如法雷级数，比如当复杂度过高时考虑预处理，比如枚举某个变量复杂度过高时考虑枚举另一个变量，还有J题我也很喜欢，喜欢那种表示状态的方式。

     最后给源代码。后面的三题过几天再做，网络流没学，模拟题又巨恶心。

     

     A ：

#include <stdio.h>
#include <string.h>
#include <map>
#include <stack>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
#define MAX 1200


struct node {

    int x,y;
}arr[MAX];
int n,m,ans,cnt;
bool vis[MAX*2][MAX*2];
map<int,int> hash;


int cmp(node a,node b) {

    if (a.x == b.x) return a.y > b.y;
    else return a.x > b.x;
}


int main()
{
    int i,j,k,t;


    scanf("%d",&t);
    while (t--) {

        scanf("%d",&n);
        ans = cnt = 0;
        hash.clear();
        memset(vis,false,sizeof(vis));
        for (i = 1; i <= n; ++i) {

            scanf("%d%d",&arr[i].x,&arr[i].y);
            //hash[arr[i]] = ++cnt;
            if (hash.find(arr[i].x) == hash.end())
                hash[arr[i].x] = ++cnt;
            if (hash.find(arr[i].y) == hash.end())
                hash[arr[i].y] = ++cnt;
            vis[hash[arr[i].x]][hash[arr[i].y]] = true;
        }


        sort(arr+1,arr+1+n,cmp);
        for (i = 1; i <= n; ++i)
            for (j = i + 1; j <= n; ++j)
                if (arr[i].x == arr[j].x){

                int len = arr[i].y - arr[j].y;
                len = abs(len);
                node cur;
                cur.x = arr[i].x + len;
                cur.y = arr[i].y;
                if (hash.find(cur.x) != hash.end()
                        && hash.find(cur.y) != hash.end()) {
                    if (vis[hash[cur.x]][hash[cur.y]] == 0)
                        continue;
                    cur.x = arr[j].x + len;
                    cur.y = arr[j].y;
                     if (hash.find(cur.x) != hash.end()
                        && hash.find(cur.y) != hash.end())
                         if (vis[hash[cur.x]][hash[cur.y]] == 1)
                             ans++;
                }
            }

        
        printf("%d\n",ans);
    }
}

     B：

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <stdio.h>
#include <string.h>
#define MAX 100
#define MOD 10001
#define int64 int//long long//__int64


int n, begin, end;
int64 m,final[MAX][MAX];
char str[MAX][MAX],tp[MAX];
struct Mat {

    int mat[MAX][MAX], size;

    Mat() {size = MAX;};
    Mat(int n) {

        size = n;
        memset(mat, 0, sizeof (mat));
    }


    friend Mat operator *(Mat a, Mat b);
    friend Mat operator +(Mat a, Mat b);
    friend Mat operator ^(Mat a, int64 k);
} E;
Mat operator *(Mat a, Mat b) {

    Mat c;
    c.size = a.size;
    memset(c.mat, 0, sizeof (c.mat));
    for (int i = 0; i < c.size; ++i)
        for (int j = 0; j < c.size; ++j)
            for (int k = 0; k < c.size; ++k)
                if (a.mat[i][k] && b.mat[k][j])
                    c.mat[i][j] = (c.mat[i][j] + a.mat[i][k] * b.mat[k][j]) % MOD;
    return c;
}
Mat operator +(Mat a, Mat b) {

    Mat c;
    c.size = 2 * n;
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            c.mat[i][j] = (a.mat[i][j] + b.mat[i][j]) % MOD;
    return c;
}
Mat operator ^(Mat a, int64 k) {

    Mat c = E;
    c.size = a.size;
    while (k) {

        if (k & 1) c = c * a;
        a = a * a, k >>= 1;
    }
    return c;
}
Mat sum1(Mat A,int k) {
	//空间复杂度为O（n*n),时间复杂度为O（log（k）*n^3）
	if (k == 1) return A;
	if (k & 1)  return sum1(A,k-1) + (A^k);
	return sum1(A,k/2) * ((A^(k / 2)) + E);
}
Mat sum2(Mat A, int64 k) {

    int i,j;
    Mat c = A;
    c.size = 2 * A.size;
    for (i = 0; i < n; ++i)
       c.mat[i][i+n] = c.mat[i+n][i+n] = 1;

    
    c = c^(k+1);
    Mat temp;
    temp.size = n;
    for (i = 0; i < n; ++i)
        for (j = 0; j < n; ++j)
            temp.mat[i][j] = (i==j?c.mat[i][j+n]-1:c.mat[i][j+n]);
    return temp;
}
int Solve() {

    int i, j;
    Mat c;
    E.size = c.size = n;
    memset(c.mat, 0, sizeof (c.mat));
    memset(E.mat, 0, sizeof (E.mat));
    for (i = 0; i < 2 * n; ++i) E.mat[i][i] = 1;
    for (i = 0; i < n; ++i)
        for (j = 0; j < n; ++j)
            if (str[i][strlen(str[i]) - 1] == str[j][0])
                c.mat[i][j] = 1;


    if (m % 2 == 0) m--;
    int cnt = (m - 1) / 2;
    Mat c2 = c * c;
    int ans = 0;
    c = c + c * sum2(c2,cnt);
    ans = (ans + c.mat[begin][end]) % MOD;
    return ans;
}


int main()
{
    int i, j, k,t;


    scanf("%d", &t);
    while (t--) {

        scanf("%d", &n);
        for (i = 0; i < n; ++i)
            scanf("%s",str[i]);
        scanf("%s",tp);
        for (i = 0; i < n; ++i)
            if (strcmp(tp,str[i]) == 0)
                begin = i;
        scanf("%s",tp);
        for (i = 0; i < n; ++i)
            if (strcmp(tp,str[i]) == 0)
                end = i;
        scanf("%d",&m);


        int ans = Solve();
        printf("%d\n",ans%MOD);
    }
}

    C：

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define MAX 1000010
#define max(a,b) (a)>(b)?(a):(b)


struct node {
    
    int x,in;
}r[MAX];
int sum[MAX],mmin[MAX];
int n,p,k,ans,hash[MAX];


int cmp(node a,node b) {
    
    if (a.x == b.x) return a.in > b.in;
    else return a.x < b.x;
}


int main()
{
    int i,j,t;
    int cas = 0,mmin;
    
    
    scanf("%d",&t);
    while (t--) {
        
        scanf("%d%d%d",&n,&p,&k);
        for (i = 1; i <= n; ++i) {
            
            scanf("%d",&sum[i]);
            r[i].in = i;
            sum[i] += sum[i-1];
            r[i].x = sum[i] % p + k;
        }
        
        
        sort(r+1,r+1+n,cmp);
        //for (i = 1; i <= n; ++i)
         //   printf("%d in = %d\n",r[i].x,r[i].in);
        mmin = n + 1;
        for (i = n; i >= 1; --i) {
            
            hash[r[i].in] = i;
            int temp = r[i].in;
            r[i].in = mmin;
            if (temp < mmin)
                mmin = temp;
        }


        //for (i = 1; i <= n; ++i)
            //printf("i = %d r[i] = %d\n",i,r[i].in);
        ans = -1;
        for (i = 1; i <= n; ++i) {

            int index = r[hash[i]].in;
            if (sum[i] % p <= k) ans = max(ans,sum[i] / p);
            if (r[index].in < i) ans = max(ans,(sum[i] - sum[r[index].in])/ p);
            //printf("i = %d ans = %d\n",i,ans);
        }


        printf("Case %d: %d\n",++cas,ans);
    }
}

    

    D：

#include <stdio.h>
#include <string.h>
#define MAX 510
#define MOD 1000007


int main()
{
    int i,j,k,n,t;
    int dp[MAX] = {0};
    dp[0] = 1;
    for (i = 2; i < MAX; ++i)
        for (j = i; j < MAX; ++j)
            dp[j] = (dp[j] + dp[j-i]) % MOD;
    
    
    scanf("%d",&t);
    while (t--) {
        
        scanf("%d",&n);
        printf("%d\n",dp[n]);
    }
}

   E：

#include <stdio.h>
#include <string.h>


int Gcd(int x,int y) {

    int r = x % y;
    while (r) {

        x = y,y = r;
        r = x % y;
    }
    return y;
}


int main()
{
    int i,j,k,t;
    int n,rest,bigest;
    

    scanf("%d",&t);
    while (t--) {
        
        scanf("%d%d",&n,&k);
        rest = (n + 1) / 2;//上取整
        if (k <= rest) {
        //前半部分，分子为1，分母递减
            printf("1/%d\n",n-k+1);
            continue;
        }


        k = k - rest;
        rest = (n + 2) / 3;
        if (k <= rest) {
        //中间部分，分子为2，分母递减
            j = Gcd(2,n-k+1);
            printf("%d/%d\n",2/j,(n-k+1)/j);
            continue;
        }


        k = k - rest;
        rest = (k - 1) % 4 + 1;
        bigest = n * 2 - (k - 1) / 4 * 6;
        while (1) {
            
            j = Gcd(6,bigest);
            if (j == 1) {
            //最大公约数为1，不是法雷级数
                bigest--;
                continue;
            }
            else if (rest == 1) {
            //最后一个法雷级数
                printf("%d/%d\n",6/j,bigest/j);
                break;
            }
            bigest--,rest--;
        }
    }
}

     F：

#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
using namespace std;
#define MIN 110
#define MAX 3300


struct bnode {
    //广搜用的node
    int dis,v;
}qu[MAX];
struct mnode {
    //建图用的node
    int v,in;
    mnode *next;
}map[MAX*2],*Head[MIN];
bool vis[MIN][MAX],used[MIN][MAX];//广搜用的判点是否搜过,判某点是否在最小路径树上
int  x[MAX],y[MAX],ans,flag;
int  ptr,n,m,sum[MAX],head,tail;


void Initial() {
    
    ptr = 0;
    memset(vis,0,sizeof(vis));
    memset(used,0,sizeof(used));
    memset(Head,NULL,sizeof(Head));
}
void AddEdge(int x,int y,int z) {
    
    map[ptr].v = y,map[ptr].in = z;
    map[ptr].next = Head[x],Head[x] = &map[ptr++];
}
int Bfs_AC(int cur,int index) {

    int cnt = 0;
    bnode now,next;


    sum[index] = 0;
    head = tail = 0;
    now.v = cur,now.dis = 0;
    qu[++head] = now;
    vis[index][cur] = true;
    
    
    while (tail < head) {

        cnt++;
        now = qu[++tail];
        sum[index] += now.dis;
        mnode *p = Head[now.v];
        while (p != NULL) {
            
            int v = p->v,in = p->in;
            if (!vis[index][v]
                    && !used[index][in]) {

                next.v = v;
                vis[index][v] = true;
                used[index][in] = true;
                next.dis = now.dis + 1;
                qu[++head] = next;
            }
            p = p->next;
        }
    }
    return cnt;
}


int main()
{
    int i,j,k,t,ta,tb;
    
    
    while (scanf("%d%d",&n,&m) != EOF) {
        
        Initial();
        for (i = 1; i <= m; ++i) {
            
            scanf("%d%d",&x[i],&y[i]);
            AddEdge(x[i],y[i],i),AddEdge(y[i],x[i],i);
        }
        
        
        for (i = 1; i <= n; ++i) Bfs_AC(i,i);
        //Debug_Input
        for (j = 1; j <= m; ++j) {

            ans = flag = 0;
            for (i = 1; i <= n && !flag; ++i) {

                if (!used[i][j]) ans += sum[i];
                else {

                    memset(vis[n+1],false,sizeof(vis[n+1]));
                    memset(used[n+1],false,sizeof(used[n+1]));
                    used[n+1][j] = true;
                    ta = Bfs_AC(i,n+1);
                    if (ta < n) flag = 1;
                    else ans += sum[n+1];
                }
            }


            if (flag) printf("INF\n");
            else printf("%d\n",ans);
        }
    }
}

     J：

#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
#define MAX 1001
#define INF 2147483647
#define min(a,b) ((a)<(b)?(a):(b))


struct node {
    
    int v,len;
}cur,next,qu[MAX];
vector<node> map[MAX];
char str[MAX];
int top,st[MAX],cnt;
int count[MAX],topo[MAX];
int s,k,n,m,ans,ansi,dp[MAX][MAX];


void Initial() {
    
    ansi = ans = -1;
    for (int i = 0; i <= n; ++i) {

        map[i].clear();
        count[i] = 0;
        for (int j = 0; j <= k; ++j)
            dp[i][j] = INF;
    }
}
void ToooPooo() {

    int i,j,v,size;


    cnt = top = 0;
    for (i = 1; i <= n; ++i)
        if (count[i] == 0) st[++top] = i;


    while (top > 0) {

        i = st[top--];
        topo[++cnt] = i;
        size = map[i].size();
        for (j = 0; j < size; ++j) {

            cur = map[i][j];
            count[cur.v]--;
            if (count[cur.v] == 0)
                st[++top] = cur.v;
        }
    }
}
void Debug_Input() {

    int i,j,t;
    for (i = 1; i <= n; ++i) 
        for (j = 0; j < k; ++j)
            printf("i = %d j = %d dp[i][j] = %d\n",i,j,dp[i][j]);
}
int Solve_AC() {
    
    int i,j,t,size,v,tp;


    dp[s][0] = 0;
    for (i = 1; i <= cnt; ++i) {

        v = topo[i];
        size = map[v].size(); 
        for (j = 0; j < size; ++j) {

            next = map[v][j];
            for (t = 0; t < k; ++t)
                if (dp[v][t] != INF) {

                    tp = (t + next.len) % k;
                    dp[next.v][tp] = min(dp[next.v][tp],dp[v][t] + (t+next.len)/k);
                }
        }
    }


    for (i = 1; i <= n; ++i)
        if (str[i] == 'P' && dp[i][0] != INF
                && (ans == -1 || dp[i][0] * k < ans))
            ansi = i,ans = dp[i][0] * k;
    return ansi;
}


int main()
{
    int i,j,t;
    int cas = 0,a,b,c;
    

    scanf("%d",&t);
    while (t--) {

        scanf("%d%d%d%d",&n,&m,&s,&k);
        scanf("%s",str+1);
        Initial();


        for (i = 1; i <= m; ++i) {
            
            scanf("%d%d%d",&a,&b,&c);
            count[b]++;
            cur.v = b,cur.len = c;
            map[a].push_back(cur);
        }
        
        
        ToooPooo();
        Solve_AC();
        printf("Case %d: %d %d\n",++cas,ans,ansi);
    }
}

本文ZeroClock原创，但可以转载，因为我们是兄弟。

ZeroClock
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2008年ACM-ICPC成都赛区现场赛题目
03-16
在"2008年ACM-ICPC成都赛区现场赛总结.JPG"这个文件中，很可能包含了赛事的整体回顾，包括比赛日的氛围、参赛队伍的表现、组织工作的亮点以及比赛过程中的精彩瞬间。这类图片文件通常用于记录和分享活动的概貌，帮助...
2020年成都市中等职业学校师生技能大赛（学生组）网络空间安全技术文件
04-07
2020年成都市中等职业学校师生技能大赛（学生组）网络空间安全技术文件
赛宁谈靶场–面向实战的网络靶场体系
Cyberpeace的博客
04-27 2710
导 语 赛宁网安聚焦网络安全攻防对抗核心技术，是国际领先的专业网络靶场提供商，产品远销全球二十多个国家。“赛宁谈靶场”是赛宁网安结合市场需求，以及自身多年实践积累推出的系列文章，围绕国际网络靶场建设分析、网络靶场建设理念、体系化网络靶场实践等进行的深入探讨。 国际靶场建设分析 网络靶场建设，被称为网络安全“曼哈顿计划”[1]，从美国国家网络靶场（NCR）建设开始，已经经历过12年的发展与演变。...
题解 | #[NOIP2008]ISBN号码#
最新发布
2301_79125642的博客
06-08 837
Webpack是一个模块打包工具，它的主要目的是将应用程序的各个模块打包成一个或多个文件，以便在浏览。五月份找到了杭州一家医疗大数据公司的实习 offer，当时以为去了是做数仓，结果是数据交付，每天写写。本硕末211计算机，26届，6级456，非党员(在积极准备入党)，有一段java小厂实习经验，毕业想。中芯东方在上海临港，每季度倒 15 个夜班，光刻设备工程师，五险一金，总包 20 出头国电投核电技术。成都人，女，考虑留家还是出去挣几年，担心年纪大了不好回成都，但直接留又不是很甘心。
转载：十年驾车经验总结：活着，才是硬道理
weixin_30920853的博客
06-16 1029
一个优秀的驾驶员，应该对自己负责、对家人负责、对他人负责，对生命心存敬畏！ 现实生活中，违章又无处不在，为什么呢？ 原因一、侥幸心理。平时不系安全带，偶尔酒后驾驶，平时闯闯红灯，晚上出来飚飚车，从来没出过事故，安全意识越来越淡薄，总感觉车技好无所谓，其实，靠侥幸是不可能幸运一辈子的，据统计：驾龄5~6年属于事故高发期。 原因二、环境因素。我在都江堰生活过3个月，在那里，闯红灯属于普遍现象，后...
Visualizing and Understanding Convolutional Networks
Tony的博客
09-13 3123
前言：研究卷积神经网络，把阅读到的一些文献经典的部分翻译一下，写成博客，代码后续给出，不足之处还请大家指出。 本文来自:tony-tan.comGithub:github.com/Tony-Tan大型卷积神经网络在图片分类上很成功，然而我们不知道他为什么能表现的如此不错，或者如何提高。Abstract： In this paper we address both issues. We intr
2022年成都建筑轮廓GIS数据
06-07
2022年成都建筑轮廓GIS数据是城市规划、建设、管理的重要资源，它包含了成都市建筑物的精确几何形状、位置信息以及可能的附加属性信息，如建筑物的高度、用途、年代等。 一、GIS数据结构与类型 GIS数据通常分为...
2008年成都市中考数学试题及答案.pdf
10-26
2008年成都市中考数学试题及答案.pdf
2021年一季度成都网络理政工作总结.docx
10-05
本文主要讲述了2021年一季度成都市在网络理政方面的成果和未来规划。成都市利用网络平台积极回应市民诉求，提升了城市治理效率和民众满意度。在这一季度，成都网络理政平台处理了474911件群众来电来信，解决率达到78...
【DP_区间DP专辑】
09-14 8071
自从天津网赛后心憔悴啊，发现DP还是太水了，1006那道区间DP竟然不会做，咳，果然是赤裸裸的水军。     今天花了一天时间写了几道区间DP的题目，大部分都是水题，然后和以前的合并起来就是这个9道题的专辑，大家可以试着AK。      区间DP是一类在区间上进行动态规划的最优问题，一般是根据问题设出一个表示状态的dp，可以是二维的也可以是三维的，一般情况下为二维。然后将问题划分成两个子问题，
2012年浙大7月月赛总结 (Zoj Monthly July 2012)
07-31 5029
本次月赛由我、DTen和sssplk完成，三台机子同时进行。      本次比赛的题目说不上特别好，因为就四种题型：数学、贪心、DP、图论，最后一题和G题有用到线段树，其他的内容似乎都没提及，不够综合，这也导致我从头敲到尾，两位可怜的队友成了翻译，从头看题看到尾。另外这场比赛被好几个神牛AK，原来AK如此简单，这也是我觉得题目不够好的原因，我想应该是Watashi不在，没出神题卡AK.
2012年浙大7月月赛 源码和部分数据
07-31 3227
解题报告请见： http://blog.csdn.net/woshi250hua/article/details/7803599  部分题目代码如下：  A题代码： #include #include #include using namespace std; int dp[1000] = { 0,1,2,5,10,20,25,50,100,125,200,250,500,
浙江第9届省赛练习总结
04-27 2917
本次练习由iBeyond成员鄙人、白翔、张君帅小朋友共同完成。      本次练习只是杭州邀请赛的热身练习，训练下默契。      本次练习只有两个屏幕，也就是说只有两份题目可以看，这导致白翔和我一起看题，所以我们在最早的时候看了A题(Taxi Fare)，就敲了A题，而不是大水题K题(Yet Another Story of Rock-paper-scissors)和
2012 ACM/ICPC Asia Regional Changchun Online 总结(长春网赛)
09-09 2739
本场比赛由我和DTen、sssplk一台机子完成，中间双开过几十分钟。      今年打网赛和去年比下变化相当大，去年比赛都是帮学校的大牛看题，想题的机会都很少因为都不知道是什么题，大部分情况是题目还没看完，实验室就传出AC了，或者看完题目和大牛讲题目意思，题目没讲完，他们就说会了。今年看到题目就可以目测是什么题，比如第一题，一看就是线段树或者树状数组或者RMQ，比如第二题一看就是贪心啊，再比如
2012年浙大9月月赛总结 (ZOJ Monthly, September 2012)
09-30 2658
本次比赛由我、DTen和ssslpk完成，一台机子进行。       因为迟到了两个小时，最终只出四题，最终排名81。其中我出了2题，Dten出了一题二分匹配，sssplk出了一道组合数学。Dten的那道二分匹配是我和他一起做的，卡了好久，正是因为这题卡太久没时间敲A题，不然A题是绝对可以AC的，赛时想的思路赛后十几分钟就AC了。      正是这场比赛，让我明白：自己最熟悉的题应该放
ZOJ Monthly, August 2012 总结|解题报告
08-28 2078
本次比赛由我、DTen和sssplk完成，一台机子进行。       自从前天RP大爆发，从刷sgu比赛进前排开始到现在就一直被虐。前一场区域热身只水2题，这场又只做三题，真是罪过啊...       这场比赛不是很难，也不是特别简单，但就是这样的比赛我们队只做了三题，两题线段树、一题并查集，其中第一题线段树在开场50分钟过掉，第二题并查集是84分钟过的，第三题线段树则到了200分钟。
2012 ACM/ICPC Asia Regional Online Warmup总结
08-26 2020
本次比赛由我、DTen和sssplk完成，一台机子进行。      本次比赛题目来自芝加哥邀请赛，题目挺全面的，也都有一定难度。这次比赛把我给虐残了，到现在还内伤中。全场比赛只A了两题最简单的题目，分别是1003和1007，一道置换群一道并查集。DTen在最后一个小时开始敲1006线段树到现在似乎还木有过，悲剧啊。sssplk则被一道几何卡住全场动弹不得。三个人都不在状态啊。
ZOJ Monthly, August 2012 部分代码和数据
08-28 1638
总结和解题报告见：http://blog.csdn.net/woshi250hua/article/details/7913903 Zoj 3634代码和数据 #include #include #define MAX 110000 #define max(a,b) ((a)>(b)?(a):(b)) double ans,mon[MAX],att[MAX]; double x
"DICOM国际会议暨研讨会:实施工具与标准 2008年成都会议资料下载
服务器应用程序可以用于检测、研究PACS和临床PACS，具备储存/查询/检索功能、异常管理和编辑功能、协调工作流以及网络服务器(WADO)和安全功能(授权/访问控制/审计)。 这些医学数字成像与通信标准的实施工具具有不同...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值