2013ACM多校联合（4）

最新推荐文章于 2024-11-04 09:37:57 发布
最新推荐文章于 2024-11-04 09:37:57 发布
阅读量58 收藏
点赞数
文章标签： 数据结构与算法 游戏
原文链接：http://www.cnblogs.com/Lyush/archive/2013/04/29/3051051.html
版权

A:ZZ买衣服

简单的字符串处理问题，需要注意的是某一天买了之后接下来的天数中不能够再次购买。

代码如下：

Problem A_set 
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <algorithm>
#include <set>
using namespace std;

int N, M;
set<string>st;

int main() {
    char str[100];
    while (scanf("%d %d", &N, &M) != EOF) {
        st.clear();
        for (int i = 0; i < N; ++i) {
            scanf("%s", str);
            st.insert(str);
        }
        for (int i = 0; i < M; ++i) {
            scanf("%s", str);
            if (st.count(str)) {
                puts("NO");    
            } else {
                st.insert(str);
                puts("YES");
            }
        }
    }    
    return 0;    
}
Problem A_hash 
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cmath>
using namespace std;
typedef unsigned long long LL;

const int MOD = 200003;
const int T = 29;

struct Node {
    int key, next;
    LL val;
}e[200005];
int head[200005];
int N, M, idx;

LL getval(char *str) {
    int len = strlen(str);
    LL val = 0;
    for (int i = 0; i < len; ++i) {
        val = val * T + str[i]-'a'+1;
    }
    return val;
}

void insert(int key, LL val) {
    e[idx].key = key, e[idx].val = val;
    e[idx].next = head[key];
    head[key] = idx++;
}

void encode(char *str) {
    LL val = getval(str);
    int key = val % MOD;
    insert(key, val);
}

bool search(char *str) {
    LL val = getval(str);
    int key = val % MOD;
    for (int i = head[key]; i != -1; i = e[i].next) {
        if (e[i].val == val) {
            return true;    
        }
    }
    return false;
}

int main() {
/*    for (int i = 2; i <= (int)sqrt(1.0*MOD); ++i) {
        if (MOD % i == 0) {
            puts("is not prime");
        }
    }*/
    char str[50];
    while (scanf("%d %d", &N, &M) != EOF) {
        idx = 0;
        memset(head, 0xff, sizeof (head));
        for (int i = 0; i < N; ++i) {
            scanf("%s", str);
            encode(str);
        }
        for (int i = 0; i < M; ++i) {
            scanf("%s", str);
            if (!search(str)) {
                puts("YES");
                encode(str);
            } else {
                puts("NO");
            }
        }
    }
    return 0;    
}

 

B:ZZ的橱柜

通过构造得出N个序列的前K大，求所有序列中的前K大，使用优先队列维护一个长度为N的序列，时间复杂度为O(N*log(N))。

代码如下：

Problem B 
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <algorithm>
#include <set>
#include <queue>
using namespace std;

const int INF = 0x7fffffff;
int A[400005], B[400005];
int N, M, idx;

struct Node {
    int x, y, val;
    Node(int xx, int yy, int v) : x(xx), y(yy), val(v) {}
    Node(){}
};

bool operator < (const Node & a, const Node & b) {
    return a.val > b.val;    
}

void solve() {
    Node t;
    priority_queue<Node>q;
    for (int i = 1; i <= N; ++i) {
        q.push(Node(i, 1, A[i]+B[1]));
    }
    int cnt = 0;
    while (cnt < M) {
        t = q.top();
        printf("%d\n", t.val);
        q.pop();
        q.push(Node(t.x, t.y+1, A[t.x]+B[t.y+1]));
        ++cnt;
    }
}

int main() {
    while (scanf("%d %d", &N, &M) != EOF) {
        idx = 0;
        for (int i = 1; i <= N; ++i) {
            scanf("%d", &A[i]);
        }
        sort(A+1, A+1+N);
        for (int i = 1; i <= N; ++i) {
            scanf("%d", &B[i]);
        }
        sort(B+1, B+1+N);
        solve();
    }
    return 0;
}

 

C:ZZ的小游戏

8数码问题，bfs搜索，通过康托展开来hash一个全排列的序列，也就是通过逆序对和递增进制数的一个一一对应。

代码如下：

Problem C 
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 362885;

int fac[10] = {1,1,2,6,24,120,720,5040,40320};
int ret[MAXN];
// 9! = 362880, 一共有这么多种状态

struct Node {
    char sta[10];
    int step;
};

Node que[MAXN];
int idx, front, tail;

int dir[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};

int get(char str[]) {
    int k, key = 0;
    for (int i = 0; i < 8; ++i) {
        k = 0;
        for (int j = i+1; j < 9; ++j) {
            if (str[j] < str[i]) { // 求逆序对的个数，这个数刚好和递增进制数契合 
                ++k;
            }
        }
        key += k * fac[8-i];
    }
    return key;
}

bool judge(int x, int y) {
    if (x < 0 || x >= 3 || y < 0 || y >= 3) return false;
    return true;
}

void bfs() {
    Node pos;
    for (int i = 0; i < 9; ++i) {
        pos.sta[i] = 8-i;
    }
    pos.step = 0;
    idx = front = tail = 0;
    int key = get(pos.sta);
    ret[key] = pos.step;
    que[tail++] = pos;
    while (front != tail) {
        pos = que[front++];
        int ze;
        for (int i = 0; i < 9; ++i) {
            if (pos.sta[i] == 0) {
                ze = i;
                break;
            }
        }
        for (int k = 0; k < 4; ++k) {
            int zx = ze/3+dir[k][0];
            int zy = ze%3+dir[k][1];
            if (!judge(zx, zy)) continue;
            swap(pos.sta[ze], pos.sta[zx*3+zy]);
            pos.step += 1;
            key = get(pos.sta);
            if (!(~ret[key])) {
                ret[key] = pos.step;
                que[tail++] = pos;
            }
            // 没有增加新的状态，原地修改后直接在原来的状态上回溯
            swap(pos.sta[ze], pos.sta[zx*3+zy]);
            pos.step -= 1;
        }
    }
}

int main() {
    memset(ret, 0xff, sizeof (ret));
    bfs();
    int T;
    char str[10];
    scanf("%d", &T);
    while (T--) {
        int c;
        for (int i = 0; i < 9; ++i) {
            scanf("%d", &c);
            str[i] = c;
        }
        int key = get(str);
        if (!(~ret[key])) {
            puts("impossible!");    
        } else {
            printf("%d\n", ret[key]);
        }
    }
    return 0;
}

 

D:ZZ的计算器

模拟，自己使用递归写的，在处理乘法和除法的时候要从后面开始，反正这题写的不是很好。

代码如下：

Problem E 
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cctype>
using namespace std;

typedef long long LL;
char str[100];
bool legal;

LL deal(int l, int r) {
    LL t = 0;
    int i = l, sign = 1;
    if (str[i] == '+') {
        i = l + 1;
    } else if (str[i] == '-'){
        sign = -1;
        i = l + 1;    
    }
    int j;
    for (j = r; j >= i; --j) {
        if (!isdigit(str[j])) {
            break;    
        }
    }
    for (int k = j+1; k <= r; ++k) {
        t = t * 10 + str[k] - '0';    
    }
    if (j < i) return sign * t;
    if (str[j] == '*') {
        return sign * deal(i, j-1) * t;
    } else {
        if (t == 0) {
            legal = false;
            return 1;
        } else {
            return sign * deal(i, j-1) / t;
        }
    }
}

LL solve(int l, int r) {
    LL t = 0;
    int i = l, sign = 1;
    if (str[l] == '-') {
        sign = -1;
        i = l + 1; 
    } else if (str[l] == '+') {
        i = l + 1;
    }
    while (isdigit(str[i]) && i <= r) {
        t = t * 10 + str[i] - '0';
        ++i;
    }
    t *= sign;
    if (i > r) return t;
    if (str[i] == '+' || str[i] == '-') {
        return t + solve(i, r);
    } else {
        int j;
        for (j = i+1; j <= r; ++j) {
            if (str[j] == '+' || str[j] == '-') {
                break;
            }
        }
        if (j > r) { 
            return deal(l, r);
        }
        return deal(l, j-1) + solve(j, r);
    }
}

int main() {
    while (scanf("%s", str) != EOF) {
        legal = true;
        LL ans = solve(0, strlen(str)-1);
        if (legal) {
            printf("%lld\n", ans);
        } else {
            puts("impossible");
        }
    }
    return 0;    
}

 

E:ZZ的研究

首先将500以内的素数全部找出来，然后对每一个数得出一个关于素因子个数的向量

设N个数分别是a1,a2...an。且已知500以内从大到小的素数为p1,p2...pk。对于ai进行素因子分解之后有：，对于任何一个数将其所有的素因子的指数单独拿出来后，N个数可以构成一下矩阵（如图a）。

                                               

            a                                             b                                                     c

现在我们回到原问题，从N个数中选择出若干个数，是的他们的乘积的平方根为一个整数。换句话说也就是要求他们乘出来后的结果素因子分解的指数均为偶数。也就是说某一个数的某个指数为偶数那么就和为0没有区别，为奇数就和1没有区别，因此矩阵的每一个元素均可以作一个mod 2 的处理，只关心各个值的奇偶性（如图b）。

对于原问题，就可以转化为求一个线性模2加方程组问题（如图c）。

其中x1,x2...xn的取值都非0即1（对应于一个数取或者是不取），这也正符合模2加方程的特点：所有元素都只需要考虑其奇偶性。若方程的解唯一，那么未知数向量的奇偶性就唯一；若不唯一，那么不定的未知量就各有两个取值，而非一般情况下的无数组解。

先求解如下：假设有n个元素，首先c图中左边矩阵中的每一个元素对2取模，然后求这个矩阵的秩，如果秩为r，那么有r个未知量值必须为0，其余两可以为0或者是1任意值，由于必须从集合中选出元素，因此最终的结果就是[2^(n-r)]-1。

代码如下：

Problem E 
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;

int p[505], num[100];
int idx, N;
struct Matrix {
    int r, c;
    int a[105][105];
    void init(int rr, int cc) {
        r = rr, c = cc;
        memset(a, 0, sizeof (a));
    }
    void rswp(int x, int y, int s) {
        if (x == y) return;
        for (int i = s; i <= c; ++i) {
            swap(a[x][i], a[y][i]);    
        }
    }
    // 高斯消元的过程其实就是讲上面一行作为条件的代入的过程 
    void relax(int x, int y, int s) {
        for (int i = s; i <= c; ++i) {
            a[y][i] ^= a[x][i];
        }
    }
    int rank() {
        int k = 1;
        // k表示未使用到的开始行 
        for (int j = 1; j <= c; ++j) {
            int hav = 0;
            for (int i = k; i <= r; ++i) {
                if (a[i][j]) {
                    hav = i;
                    break;    
                }
            }
            if (!hav) continue;
            rswp(k, hav, j);
            for (int i = hav+1; i <= r; ++i) {
                if (a[i][j]) {
                    relax(k, i, j);
                }
            }
            ++k;
        }
        return k-1;
    }
};
// 定义一个系数矩阵

Matrix M;

void pre() {
    idx = 1;
    int LIM = (int)sqrt(500.0);
    for (int i = 4; i <= 500; i+=2) {
        p[i] = 1;
    }
    for (int i = 3; i <= LIM; i+=2) {
        int k = 2*i;
        for (int j = i*i; j <= 500; j+=k) {
            p[j] = 1;    
        }
    }
    for (int i = 2; i < 500; ++i) {
        if (!p[i]) {
            num[idx++] = i;
        }
    }
//  共95个素因子
//    printf("idx = %d\n", idx);
}

void deal(int s, LL x) {
    int cnt;
    for (int i = 1; i < idx; ++i) {
        if (x % num[i] == 0) {
            cnt = 0;
            while (x % num[i] == 0) {
                ++cnt;
                x /= num[i];
            }
            if (cnt & 1) M.a[i][s] = 1; // 第a个数在第j个素数的贡献上为1 
        }
    }
}

int main() {
    pre();
    int T;
    scanf("%d", &T);
    while (T--) {
        LL x;
        scanf("%d", &N);
        M.init(idx-1, N);
        for (int i = 1; i <= N; ++i) {
            scanf("%lld", &x);
            deal(i, x);
        }
        printf("%lld\n", (1LL<<(N-M.rank()))-1);
    }
    return 0;    
}

 

F:ZZ’s Fibonacci Problem

这题首先要找到每一个数的这样一种分解：任何一个数都能够被唯一分解成不相邻的若干个菲波那契数之和。如果把分解看作是是否第i个菲波那契数的向量的话。也就是1的数量最少的一个向量。对于题中所要求计算的其他分解方式就是在这个基础上进行的，问题转化为某一位的1分或者是不分。

例如：105 = 3 + 13 + 89 对应于向量 0010010001。

设状态dp[i][0]表示第i个菲波那契数进行不进行分解的方案数，dp[i][1]表示第i个菲波那契数进行分解。这里有这样一个推论：某一个1有多少种分解是一个其前面有多少个0的函数。

例如考虑 0000001 存在这样的分解路线 0000001 -> 0000110 -> 00110100 -> 11010100

观察到每一分解后一个1总是无法再往前移动的，而只有前面一个1能够往前移动，如果0的个数为x的话，移动的次数恰好为x/2。

如此便有动态规划方程：

dp[i][1] = dp[i-1][0] + dp[i-1][1]
dp[i][0] = dp[i-1][0] * （相邻1之间0的个数加1）/2 + dp[i-1][1] *（相邻1之间0的个数）/2

代码如下：

Problem F 
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long LL;
LL fi[90];
LL N;
int dp[90][2];
int idx, a[90];

// 其中a数组使用来记录哪个位置有1

void pre() {
    fi[0] = fi[1] = 1;
    int idx, i;
    for (i = 2; i <= 86; ++i) {
        fi[i] = fi[i-1] + fi[i-2];
    } // 第86个数是小于10^18且最接近10^18的数
}

void DP() {
    memset(dp, 0, sizeof (dp));
    dp[0][1] = 1;
    for (int i = 1; i < idx; ++i) {
        dp[i][1] = dp[i-1][0] + dp[i-1][1];
        dp[i][0] = dp[i-1][1] * ((a[i]-a[i-1]-1)/2) + dp[i-1][0] * ((a[i]-a[i-1])/2);
    }
    printf("%d\n", dp[idx-1][0] + dp[idx-1][1]);
}

void solve() {
    idx = 1;
    for (int i = 86; i >= 1; --i) {
        if (N >= fi[i]) {
            N -= fi[i];
            a[idx++] = i; // 表示i位置有一个1
        }
    }
    for (int i = 1, j = idx-1; i < j; ++i, --j) {
        swap(a[i], a[j]);
    }
    DP();
}

int main() {
    pre();
    int T;
    while (scanf("%d", &T) != EOF) {
        while (T--) {
            scanf("%lld", &N);
            solve();
        }
    }
    return 0;
}

 

G:ZZ的搬砖难题

简单网络流

代码如下：

Problem F 
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>
#define INF 0x3fffffff
#define RE(x) (x)^1
#define MAXN 10005
using namespace std;

int N, M, head[MAXN], lvl[MAXN], idx;
int SS, TT;

struct Edge
{
    int No, cap, next;
}e[1005];

void init()
{
    idx = -1;
    memset(head, 0xff, sizeof (head));
}

void insert(int x, int y, int z)
{
    ++idx;
    e[idx].No = y;
    e[idx].cap = z;
    e[idx].next = head[x];
    head[x] = idx;
    ++idx;
    e[idx].No = x;
    e[idx].cap = 0;
    e[idx].next = head[y];
    head[y] = idx;
}

bool bfs()
{
    int pos;
    queue<int>q;
    memset(lvl, 0xff, sizeof (lvl));
    lvl[SS] = 0;
    q.push(SS);
    while (!q.empty()) {
        pos = q.front();
        q.pop();
        for (int i = head[pos]; i!=-1; i = e[i].next) {
            if (e[i].cap > 0 && lvl[e[i].No]==-1) {
                lvl[e[i].No] = lvl[pos]+1;
                q.push(e[i].No);  // 注意不要直接把“i”push进去了 
            }
        }
    }
    return lvl[TT] != -1;
}

int dfs(int u, int flow)
{
    if (u == TT) {
        return flow;
        // 结束条件，把流推到了T节点（汇点） 
    }
    int tf = 0, f;
    for (int i = head[u]; i != -1; i = e[i].next) {
        if (lvl[u]+1 == lvl[e[i].No] && e[i].cap > 0 && (f = dfs(e[i].No, min(e[i].cap, flow - tf)))) {
            e[i].cap -= f;
            e[RE(i)].cap += f;
            tf += f;
        }
    }
    if (tf == 0) {
        lvl[u] = -1;
        // tf等于零表示该点没有进行增广的能力，应及时将其高度赋值为-1，防止第二次被搜索到 
    }
    return tf;
}

int main()
{
    int ans, a, b, c, M;
    while (scanf("%d %d", &SS, &TT) != EOF) {
        init();
        ans = 0;
        scanf("%d", &M);
        for (int i = 0; i < M; ++i) {
            scanf("%d %d %d", &a, &b, &c);
            insert(a, b, c);
        }
        while (bfs()) {
            ans += dfs(SS, INF);
        }
        printf("%d\n", ans);
    }
    return 0;    
}

 

H:ZZ love Cookies

简单题，统计下袋子总和各个袋子的的奇偶性即可。

代码如下：

Problem H 
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <algorithm>
#include <set>
using namespace std;

int N;
int seq[100005];

int ret1, ret2, tot;

int main() {
    while (scanf("%d", &N) != EOF) {
        ret1 = ret2 = tot = 0;
        for (int i = 1; i <= N; ++i) {
            scanf("%d", &seq[i]);
            if (seq[i] & 1) ++ret1;
            else ++ret2;
            tot += seq[i];
        }
        printf("%d\n", (tot & 1) ? ret1 : ret2);
    }
    return 0;    
}

 

转载于:https://www.cnblogs.com/Lyush/archive/2013/04/29/3051051.html

weixin_34107739
关注
2013ACM多校联合(1)_CSUST(标程+数据)第一次修改
03-17
标题 "2013ACM多校联合(1)_CSUST(标程+数据)第一次修改" 暗示这是一个关于ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）的比赛资料集，包含了2013年3月17日某场赛事的题目解析、...
ACM 2013暑假多校训练7标程+解题报告
08-13
这份资料集包含了2013年暑假期间多所学校联合举办的训练活动中的标准解题代码和详细的解题报告，对于学习算法、提高编程能力以及备战ACM比赛具有极高的参考价值。 首先，我们要理解ACM竞赛的性质。国际大学生程序...
2013ACM多校联合(4)_NUN-ZZ love Cookies
ZXLS-ZMR的专栏
04-28 777
这道题，先是没弄清题意。后来才明白，这又是道水题啊。 代码如下： #include int main() { int i,n; int a[1005]; while(~scanf("%d",&n)) { int Q=0,sum=0; for(i=0;i<n;i++) { scanf("%d",&a[i]); sum+=a[i]; } i
2013ACM多校联合(4)_NUN -ZZ买衣服
ZXLS-ZMR的专栏
04-28 1031
题意：衣服的品牌是有字符串表示，ZZ买衣服不喜欢买相同的品牌。（字符串的长度小于20，N,M小于100000）输入N，M，第一个表示她已经有了N种品牌的衣服，M代表她将要买的品牌衣服。如果以前没有这种品牌的衣服就输出YES，否则就输出NO。这题真坑了我，我没注意，M输入的品牌要加入她已经买过的品牌，先没注意到这点，直接就想到了二分查找。交上去WA几次了。后来问学长。才知道这回事。二分查找就行不通了
2013ACM多校联合（2）
weixin_30416871的博客
03-30 67
A:小Y做家教 简单的想法题。使用hash表或者是map存储所有数，然后从最小的数开始找从这个数开始的连续P倍数的个数X，那么需要删除的数的个数为X/2。 代码如下： Problem A B:小Y的难题Ⅰ 组合数学题，通过经典的一一对应原则推导出答案为N^(N-2)。http://wenku.baidu.com/view/2e1ab2757fd5360cba1adbba.htmlC...
2013ACM多校联合（1）
weixin_30414635的博客
03-16 51
A:Non-negative Partial Sums 题意：给定一个序列，我们能够给这个序列做一个循环移位的操作，即把第一个数字放到整个序列的最后一位。问存在多少种移动后的状态满足对于所有的前缀和都大于等于0。 解法：对于一个长度为N的序列，设从1-i的前缀和为sum[i]，假设已经有K个数字从前面移动到序列的后面，那么对于当前序列的前N-K个元素减少的值为移动到后面的K个数字的...
2013ACM多校联合(1)_CSUST
好久不见
03-18 1172
/* G 题 类型：搜索。。。 题意：中文 解析：各种减枝，特别是奇偶减枝。。判断（步数%2）==(（ex+ey-sx-sy）%2) */ #include #include #include #include #define manx 55 using namespace std; int n,m,s,sx,sy,flag,ex,ey; char mp[m
2013ACM多校联合--【数学】
只为给你最好的的明天。
05-01 588
[提交][状态][讨论版] 题目描述 给出数列A1;A2; : : : ;AN，并设 现要求把所有的Bi 算出来。 输入 输入包含多组测试数据。对于每组数据，第1 行，1 个整数N(1   行，N 个整数A1,A2, ......,AN(1  输出 对于每组数据，输出一行，N 个整数用空格分隔，表示算出的B1,B2, ....
2013ACM多校联合(1)_CSUST 题解
05-15 1181
第一题：http://www.acmore.net/problem.php?id=1461     这题的题意是：  给你一个长度为n的数字序列，这n个数字序列可以向右移动K次（0 满足 前i个数的和 大于等于0(1    很容易想到一种暴力的方法。求出以i为第一项 往后扫描 扫n个数。  i后不足n个数的右从1开始计数。  检查这个序列是否满足题意。  这样暴力的时间复杂度是o（N^2）.
2017多校联合第一场 1006题 hdu 6038 Function 循环节
kkkkahlua的博客
07-26 718
题目链接 题意： Please calculate the quantity of different functions f satisfying that f(i)=bf(ai) for each i from 0 to n−1. （嗯...就是这样） 思路： 首先可以将 a 数组划分成若干个循环节，每个节是相互独立的，取其中一个节来看，令其长度为 l
一道优先队列的题...- 2013ACM多校联合(4)_NUN - ZZ的橱柜
zzyzzy12
05-06 1330
Problem B: ZZ的橱柜 Time Limit: 1 Sec  Memory Limit: 64 MB Submit: 345  Solved: 48  Description ZZ不仅喜欢买衣服，还是个吃货，天哪！现在的妹纸是怎么了？╮(╯_╰)╭，ZZ有两个大型橱柜A和B，里面放满了零食,每个橱柜里面有N个方格，每个方格里面放了不同重量的美味，现
2009ACM多校联合暑期集训（4）解题报告 感谢各校的努力
10-12
这篇文章是关于2009年ACM多校联合暑期集训第四次训练的解题报告，涉及了多个算法和编程问题的解决方案。以下是各题目的详细解析： 1. **题目1001：Beans** 这是一个动态规划（DP）问题。题目要求考虑两种情况：...
2012ACM多校联合比赛
09-03
### 2012ACM多校联合比赛知识点解析 #### Program A：密码 ##### 题目背景 本题目要求实现一个简单的字母加密算法，适用于军事或信息安全领域中的通信加密需求。 ##### 题目描述 为了保障通信的安全性，发送的信息...
ACM 2013暑假 多校训练9标程+解题报告
09-06
标题 "ACM 2013暑假 多校训练9标程+解题报告" 提供的信息表明，这是一个关于ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）的培训资源，具体是2013年暑假期间的一次多校联合训练活动...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 460
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
查找算法简记
well_fly的博客
10-30 609
简单记录查找算法相关知识点
C++算法第五天
2302_80418176的博客
10-31 1057
1. 首这个解法叫滑动窗口，本质是同向双指针2. 使用这个解法的原因是利用了单调性3.滑动窗口的正确性：利用的单调性，规避了没必要的枚举行为4.枚举二字算是在博主的文章中第一次出现，那么我也解释枚举是什么意思，枚举就是将每一种情况都一一列举出来。
模拟退火算法求解TSP问题
最新发布
m0_56408077的博客
11-04 335
模拟退火算法（Simulated Annealing, SA）是一种通用的随机优化算法，适合解决组合优化问题，如旅行商问题（TSP）。TSP 问题的目标是给定一组城市，找到一条闭合路径，使得旅行商从一个城市出发，访问每个城市恰好一次并最终返回起点，同时路径总长度最短。
实习冲刺Day11
2301_78814687的博客
11-02 315
c++中字符串有两种存储方式，一种是存储在char[]数组中，一种是存储在c++封装的string类中。在C中也可以使用字符指针来访问一个字符串,通过字符指针指向存放字符串数组的首元素地址来进行访问.在C中，并没有字符串这个数据类型，而是使用。char[]来保存字符串。二叉树的先序遍历根左右。二叉树的后序遍历左右根。
ACM入门与HDUACM2013竞赛概述
杭州电子科技大学（HDU）在ACM竞赛中有着重要地位，自2003年起，该校开始参加各类ACM相关比赛，包括浙江省大学生程序设计竞赛和ACM国际大学生程序设计亚洲区预选赛。 HDUACM201303版的课程内容涵盖了ACM入门介绍，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值