2016"百度之星" - 初赛（Astar Round2A）

最新推荐文章于 2016-05-24 19:28:47 发布
最新推荐文章于 2016-05-24 19:28:47 发布
阅读量698 收藏
点赞数
文章标签： 百度之星2016
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ok_again/article/details/51472659
版权

5690 All X

由于mod一个很小的数，所以把数拆成1111...11*x%k，等价于1%k+10%k+...+1em%k，显然这个东西循环节很小。于是找一下循环节就好了。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define inf 0x3f3f3f3f
#define CLR(a, b) memset(a, b, sizeof(a))

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

using namespace std;

const int maxn = 10100;

int md[maxn], st[maxn];

int main() {
    int T, cas = 1;
    scanf("%d", &T);
    while(T --) {
        int x, c, k; LL m;
        scanf("%d%I64d%d%d", &x, &m, &c, &k);
        int a = 1, cnt = 0;
        CLR(st, -1);
        int c1, c2;
        md[0] = 1;
        st[1] = 0;
        while(true) {
            cnt ++;
            a = a * 10 % c;
            if(st[a] != -1) {
                c2 = cnt;
                c1 = st[a];
                break;
            }
            md[cnt] = a;
            st[a] = cnt;
        }
        int ans = 0;
        for(int i = 0; i < min(c1 * 1ll, m); i ++) {
            ans += md[i];
            ans %= c;
        }
        if(m > c1) {
            int tmp = 0;
            for(int i = c1; i < c2; i ++) {
                tmp = (tmp + md[i]) % c;
            }
            int cc = c2 - c1;
            ans += 1ll * tmp * ((m - c1) / cc) % c;
            m = (m - c1) % cc + c1;
            for(int i = c1; i < m; i ++) {
                ans += md[i];
                ans %= c;
            }
        }
        printf("Case #%d:\n", cas ++);
        ans = ans * x % c;
        puts(ans == k ? "Yes" : "No");
    }
    return 0;
}


5691 Sitting in Line

dp[i][j][k]表示算到第i个位置，当前状态是j最后一个数是k的最大值是多少。然后发现这样会超时，由于j可以完整的表示出状态来，所以可以把i这层给去掉。于是复杂度16*16*2^16

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

int dp[1<<17][17];
int must[17];
int a[17];
int cnt[1<<17];

int main() {
    int T, cas = 1;
    for(int i = 0; i < (1<<16); i ++) {
        cnt[i] = 0;
        for(int j = 0; j < 16; j ++) if((1<<j) & i)
            cnt[i] ++;
    }
    scanf("%d", &T);
    while(T --) {
        int n;
        scanf("%d", &n);
        CLR(must, -1);
        for(int i = 0; i < n; i ++) {
            int p; scanf("%d%d", &a[i], &p);
            if(p != -1) must[p] = i;
        }
        for(int j = 0; j < (1<<n); j ++) {
            for(int k = 0; k < n; k ++) dp[j][k] = -INF;
        }
        if(must[0] == -1) {
            for(int i = 0; i < n; i ++) {
                dp[1<<i][i] = 0;
            }
        }
        else dp[1<<must[0]][must[0]] = 0;
        for(int j = 0; j < (1<<n); j ++) {
            for(int k = 0; k < n; k ++) if(dp[j][k] != -INF) {
                if(must[cnt[j]] == -1) {
                    for(int s = 0; s < n; s ++) if(((1<<s) & j) == 0) {
                        dp[(1<<s) | j][s] = max(dp[(1<<s) | j][s], dp[j][k] + a[k] * a[s]);
                    }
                }
                else  {
                    int s = must[cnt[j]];
                    if(((1<<s) & j) == 0) {
                        dp[(1<<s) | j][s] = max(dp[(1<<s) | j][s], dp[j][k] + a[k] * a[s]);
                    }
                }
            }
        }
        int ans = -INF;
        for(int i = 0; i < n; i ++) ans = max(ans, dp[(1<<n)-1][i]);
        printf("Case #%d:\n%d\n", cas ++, ans);
    }
    return 0;
}


5692 Snacks

显然，一个节点u的值，对于其所有儿子节点的影响就是该节点的值。然后修改和查询就很明显了。就是每次修改整个子树或查询子树最大值。然后就可以根据dfs序，把每个子树搞成一个区间。然后线段树随便做做。由于我交的时候还不能用C++，于是手写栈了。

#pragma comment(linker, "/STACK:102400000000,102400000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

const int maxn = 100100;

vector<int> G[maxn];
int L[maxn], R[maxn];
int a[maxn];
int dfn = 1;

LL seg[maxn << 2], add[maxn << 2];

void up(int rt) {
    seg[rt] = max(seg[rt << 1], seg[rt << 1 | 1]);
}

void down(int rt) {
    if(add[rt]) {
        add[rt << 1] += add[rt];
        seg[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        seg[rt << 1 | 1] += add[rt];
        add[rt] = 0;
    }
}

void build(int l, int r, int rt) {
    seg[rt] = add[rt] = 0;
    if(l == r) return ;
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
}

void update(int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        add[rt] += v;
        seg[rt] += v;
        return ;
    }
    down(rt);
    int m = (l + r) >> 1;
    if(L <= m) update(L, R, v, lson);
    if(R > m) update(L, R, v, rson);
    up(rt);
}

LL query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) {
        return seg[rt];
    }
    down(rt);
    int m = (l + r) >> 1;
    LL ret = -1ll * INF * INF;
    if(L <= m) ret = max(ret, query(L, R, lson));
    if(R > m) ret = max(ret, query(L, R, rson));
    return ret;
}

struct Node {
    int u, p, i;
    Node() {}
    Node(int u, int p, int i) : u(u), p(p), i(i) {}
};
void dfs(int u, int p) {
    stack<Node> S; S.push(Node(u, p, 0));
    dfn = 1;
    L[u] = dfn ++;
    while(!S.empty()) {
        Node u = S.top(); S.pop();
        if(u.i == G[u.u].size()) {
            R[u.u] = dfn - 1;
            continue;
        }
        u.i ++; S.push(u);
        int v = G[u.u][u.i - 1];
        if(v == u.p) continue;
        L[v] = dfn ++;
        S.push(Node(v, u.u, 0));
    }
}
/**
void dfs(int u, int p) {
    L[u] = dfn ++;
    for(int i = 0; i < G[u].size(); i ++) {
        int v = G[u][i];
        if(v == p) continue;
        dfs(v, u);
    }
    R[u] = dfn - 1;
}
*/

int main() {
    int T, cas = 1;
    scanf("%d", &T);
    while(T --) {
        int n, m;
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; i ++) {
            G[i].clear();
        }
        for(int i = 1; i < n; i ++) {
            int u, v; scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        for(int i = 0; i < n; i ++) {
            scanf("%d", &a[i]);
        }
        dfn = 1;
        build(1, n, 1);
//        puts("-----");
        dfs(0, -1);
        for(int i = 0; i < n; i ++) {
            update(L[i], R[i], a[i], 1, n, 1);
        }
        printf("Case #%d:\n", cas ++);
        while(m --) {
            int op, x; scanf("%d%d", &op, &x);
            if(op == 0) {
                int y; scanf("%d", &y);
                update(L[x], R[x], y - a[x], 1, n, 1);
                a[x] = y;
            }
            else {
                printf("%I64d\n", query(L[x], R[x], 1, n, 1));
            }
        }
    }
    return 0;
}


5693 D Game

这题比较有意思，其实可以看出，一个任意长度的等差序列，可以拆成长度为2或3个长度。于是问题就变成了找所有长度是2的和长度是3的序列。然后就可以区间dp去做了。判断一个区间是都可行有三种情况

1、该区间[l, r]的两个端点的差在D中，而且[l + 1, r - 1]可以被删掉。

2、该区间[l, r]可以由两个区间[l, k]+[k+1, r] 完整的删掉。

3、该区间可以拆成 l, [l+1, k-1], k, [k+1, r-1], r其中l, k, r是等差的，而且另外两个可以被删掉。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define inf 0x3f3f3f3f
#define CLR(a, b) memset(a, b, sizeof(a))

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

using namespace std;

const int maxn = 333;

LL a[maxn];

bool dp[maxn][maxn];
int dp2[maxn];
map<LL, int> mp;

int main() {
    int T;
    scanf("%d", &T);
    while(T --) {
        int n, m;
        CLR(dp, false);
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i ++) {
            dp[i][i + 1] = 1;
            scanf("%I64d", &a[i]);
        }
        mp.clear();
        for(int i = 1; i <= m; i ++) {
            int d; scanf("%d", &d);
            mp[d] = i;
        }
        for(int d = 1; d <= n; d ++) {
            for(int j = 1; j + d <= n; j ++) {
                int i = j + d;
                if(mp.count(a[i] - a[j]) && dp[i - 1][j + 1]) {
                    dp[i][j] = 1;
                    continue;
                }
                for(int k = j + 1; k < i; k ++) {
                    if(dp[i][k] && dp[k - 1][j]) dp[i][j] = true;
                    if(a[k] + a[k] == a[i] + a[j] && mp.count(a[i] - a[k])) {
                        if(dp[i - 1][k + 1] && dp[k - 1][j + 1])
                            dp[i][j] = 1;
                            break;
                    }
                }
            }
        }
        CLR(dp2, 0);
        for(int i = 1; i <= n; i ++) {
            dp2[i] = max(dp2[i], dp2[i - 1]);
            for(int j = i - 1; j >= 1; j --) if(dp[i][j]) {
                dp2[i] = max(dp2[i], dp2[j - 1] + i - j + 1);
            }
        }
        printf("%d\n", dp2[n]);
    }
    return 0;
}


5694 BD String

首先，对于S[i]来说，他的后半段是由S[i-2]+D+reverse(flip(S[i-2]))组成的（可以把reverse(flip(S[i-1]))化简下），于是就可以根据长度来一点点算B的个数了。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define inf 0x3f3f3f3f
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;


const int maxn = 1111;

LL A[maxn], B[maxn], D[maxn];

LL gao(LL n) {
    LL ret = 0;
    int l = 0;
    if(n == 0) return 0;
    while(A[l + 1] <= n) l ++;
    ret = B[l];
    int flip = 1;
    n -= A[l];
    if(n) n --, ret ++;
    l --;
    while(l >= 0) {
        if(!n) break;
        if(A[l] > n) {
            flip = 0;
            l --; continue;
        }
        n -= A[l];
        ret += B[l];
        if(n) {
            n --;
            if(flip == 0) ret ++;
        }
        flip = 1;
        l --;
    }
    return ret;
}

int main() {
    int T, cas = 1;
    A[0] = 1; B[0] = 1; D[0] = 0;
    for(int i = 1; i < 1000; i ++) {
        A[i] = A[i - 1] * 2 + 1;
        B[i] = B[i - 1] + D[i - 1] + 1;
        D[i] = B[i - 1] + D[i - 1];
    }
    scanf("%d", &T);
    while(T --) {
        LL L, R;
        scanf("%I64d%I64d", &L, &R);
        printf("%I64d\n", gao(R) - gao(L - 1));
    }
    return 0;
}


5695 Gym Class

显然这个求最大拓扑序。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define inf 0x3f3f3f3f
#define CLR(a, b) memset(a, b, sizeof(a))

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

using namespace std;

const int maxn = 100100;

vector<int> G[maxn];
int d[maxn];

int main() {
    int T, cas = 1;
    scanf("%d", &T);
    while(T --) {
        int n, m;
        scanf("%d%d", &n, &m);
        CLR(d, 0);
        for(int i = 1; i <= n; i ++)
            G[i].clear();
        for(int i = 1; i <= m; i ++) {
            int u, v; scanf("%d%d", &u, &v);
            G[u].push_back(v);
            d[v] ++;
        }
        priority_queue<int> Q;
        int mm = n + 1;
        for(int i = 1; i <= n; i ++) {
            if(d[i] == 0) Q.push(i);
        }
        LL ans = 0;
        while(!Q.empty()) {
            int u = Q.top(); Q.pop();
            mm = min(u, mm);
            ans += mm;
            for(int i = 0; i < G[u].size(); i ++) {
                int v = G[u][i];
                d[v] --;
                if(d[v] == 0) Q.push(v);
            }
        }
        printf("%I64d\n", ans);
    }
    return 0;
}


ok_again
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
A星 a星 a-star astar的python实现
10-28
A星 a星 a-star astar的python实现
Astar2007百度之星程序设计大赛网络资格赛（初赛） 题
11-06
根据给定的信息，我们可以分析出这是关于Astar2007百度之星程序设计大赛网络资格赛（初赛）的相关题目及解析。以下是对各题目所涉及的知识点进行详细阐述： ### 第一题：时间线问题 #### 题目描述： 本题要求处理...
2016"百度之星" - 初赛（Astar Round2A） 1006 Gym Class 拓扑排序
weixin_30323961的博客
05-21 84
Gym Class Time Limit: 6000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description 众所周知，度度熊喜欢各类体育活动。 今天，它终于当上了梦寐以求的体育课老师。第一次课上，它发现一个有趣的事情。在上课之前，所有同学...
hdu-5695 Gym Class(贪心+拓扑排序)
weixin_30940783的博客
05-21 181
题目链接： Gym Class Time Limit: 6000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description 众所周知，度度熊喜欢各类体育活动。今天，它终于当上了梦寐以求的体育课老师。第一次课上，它发现一个有趣的事情。在上课之前，所有同学要排成一列， ...
2016"百度之星" - 初赛（Astar Round2A）1001 All X （模）
LzyRapX
05-21 2261
All X Accepts: 1281 Submissions: 7580 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description F(x,m) 代表一个全是由数字x组成的m位数字。请计算，以下式子
2016"百度之星" - 初赛（Astar Round2A）1005 BD String (找规律)
LzyRapX
05-21 1252
BD String Accepts: 388 Submissions: 1164 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description 众所周知，度度熊喜欢的字符只有两个：B和D。 今天，它发明了一种
2016"百度之星" - 初赛（Astar Round2A）Sitting in Line
仰望星空
05-24 702
之前写状压DP都是用递归写的，感觉递归写好理解，没想到这次递归超时了，没办法，看了一下循环写的状压DP1.先说一下我对旅行商问题用循环写状压的理解下面是旅行商问题的核心代码for(int s=0;s<(1<<n);s++) fill(dp[s],dp[s]+n,inf); dp[(1<<n)-1][0]=0; for(int s=(1<<n)-2;s>=0;s--)
混合A星算法-Hybrid_Astar（matlab）
12-02
混合A星算法（Hybrid A*）是一种在路径规划领域广泛应用的智能搜索算法，它结合了经典的A*算法和其它优化策略，以提高路径搜索效率和质量。在本项目中，混合A*算法被用于车辆的路径规划，利用车辆的运动学模型来定义...
Go-go-astar-A星路径搜索算法的Go实现
08-14
A星(A*)路径搜索算法是一种在图形中寻找从起点到终点最短路径的高效搜索算法。它结合了最佳优先搜索和Dijkstra算法的优点，通过引入启发式函数来预测每个节点到达目标的潜在代价，从而减少了搜索空间，提高了效率。...
Astar2009百度之星程序设计大赛(初赛)试题1.doc
06-13
Astar2009百度之星程序设计大赛(初赛)试题1
2016"百度之星" - 初赛（Astar Round2A）题解
Miracle_ma的专栏
05-21 3202
今天是一年一度的百度之星初赛的日子啊，大家都早早的准备好了比（上）赛（分），运气也不错，涨了不少分，rating到了2222（真尼玛2） ps.我是开黑做的，所以这分数不代表真实水平，勿黑1001给你一个由m个x组成的数字，模上k，问你是否等于c k和c都小于10000，所以可以模拟，因为循环节不会大于10000，但是模拟很容易错，因为找到循环节的地方需要扣掉前面一段，然后各种XJB搞 模拟代
简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习
最新发布
08-09
阿齐archie简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习 简历是展示个人经历、技能和能力的重要文档，以下是一个常见的简历格式和内容模板，供您参考： 简历格式： 头部信息：包括姓名、联系方式（电话号码、电子邮件等）、地址等个人基本信息。 求职目标（可选）：简短描述您的求职意向和目标。 教育背景：列出您的教育经历，包括学校名称、所学专业、就读时间等。 工作经验：按时间顺序列出您的工作经历，包括公司名称、职位、工作时间、工作职责和成就等。 技能和能力：列出您的专业技能、语言能力、计算机技能等与职位相关的能力。 实习经验/项目经验（可选）：如果您有相关实习或项目经验，可以列出相关信息。 获奖和荣誉（可选）：列出您在学术、工作或其他领域获得的奖项和荣誉。 自我评价（可选）：简要描述您的个人特点、能力和职业目标。 兴趣爱好（可选）：列出您的兴趣爱好，展示您的多样性和个人素质。 参考人（可选）：如果您有可提供推荐的人员，可以在简历中提供其联系信息。 简历内容模板： 姓名: 联系方式: 地址: 求职目标: （简
CSS技巧专栏一日一例：21 -纯CSS实现拟真电器按钮特效.zip
08-09
这是一个CSS实现的拟真电器按钮特效.zip 需要看看效果的，可以移步到我的专栏去看看。文章名与资源名一致。 资源特点：代码短小、代码容易阅读、重点注释、方便扩展、样式美观、CSS+JS实现。 适用人群：前端从业职，新手小白，有网站开发能力对美工有所欠缺的后端工程师。
IATF16949审核准备资料.xls
08-09
IATF16949审核准备资料
汇编语言学习笔记.zip
08-09
汇编语言学习笔记.zip
ssm_153_mysql_健身房众筹系统_.zip
08-09
本次健身房众筹系统的实现过程，它的开发使用B/S结构即浏览器和服务器结构框架，前端采用Java web开发语言，数据库使用了Mysql数据库，页面设计采用了MVC框架，后端采用了Javascrip等其他一些脚本语言，使用到在大学里面学的软件工程导论课程、Mysql数据库、数据库原理、Javascrip高级程序设计等方面的知识完成本系统。本文结合系统开发全过程，详细阐述了此次健身房众筹系统的研究背景、设计理念、模型结构，将所学知识充分融入到本网站的开发实践中，同时简略介绍了开发使用的相关技术，并对系统概要设计、系统实现与系统测试等进行了详细的介绍。
【创新发文无忧】Matlab实现星雀优化算法NOA-DELM的故障诊断算法研究.rar
08-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
2012百度之星编程大赛试题详解及奖品揭秘
2012百度之星程序设计大赛是一场面向...2012百度之星程序设计大赛是一次全面检验选手编程技能、问题解决能力以及对IT技术综合运用的实战竞赛，不仅考验选手的专业技能，也包含了实际项目中的应用场景和用户体验考虑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值