字典树基础题总结

最新推荐文章于 2023-01-06 17:27:26 发布
最新推荐文章于 2023-01-06 17:27:26 发布
阅读量347 收藏
点赞数 1
分类专栏： ACM_HDU ACM_POJ 字符串_字典树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen_ze_hua/article/details/52038612
版权

HDU 1251 统计难题

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 26

struct Trie{
    int val;
    Trie *next[MAX];
};

Trie *root;

void Insert(char *s){
    int n = strlen(s);
    Trie *pre = root,*cur;
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL){
            cur = new Trie();
            cur->val = 1;
            for(int j = 0; j < MAX; j++) cur->next[j] = NULL;
            pre->next[id] = cur;
            pre = pre->next[id];
        }else{
            pre = pre->next[id];
            pre->val++;
        }
    }
}

int Find(char *s){
    int n = strlen(s);
    Trie *pre = root;
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL) return 0;
        pre = pre->next[id];
    }
    return pre->val;
}

void Delete(Trie *rt){
    if(NULL == rt) return ;
    for(int i = 0; i < MAX; i++){
        if(rt->next[i] != NULL) Delete(rt->next[i]);
    }
    delete rt;
    rt = NULL;
}

int main(){
    char s[15];
    root = new Trie();
    for(int i = 0; i < MAX; i++)
        root->next[i] = NULL;
    while(gets(s) && strcmp(s,"") != 0){
        Insert(s);
    }

    while(gets(s) != NULL){
        printf("%d\n", Find(s));
    }
    Delete(root);
    return 0;
}

HDU 1305Immediate Decodability

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 10

struct Trie{
    int val;
    Trie *next[MAX];
};

Trie *root;

bool Insert(char *s){
    int n = strlen(s);
    Trie *pre = root,*cur;
    int flag = 1;
    for(int i = 0; i < n; i++){
        int id = s[i] - '0';
        if(pre->next[id] == NULL){
            flag = 0;
            cur = new Trie();
            cur->val = 0;
            for(int j = 0; j < MAX; j++) cur->next[j] = NULL;
            pre->next[id] = cur;
            pre = pre->next[id];
        }
        else{
            pre = pre->next[id];
            if(pre->val) return false;
        }
    }
    pre->val = 1;
    if(flag) return false;
    else return true;
}

void Delete(Trie *rt){
    if(NULL == rt) return ;
    for(int i = 0; i < MAX; i++){
        if(rt->next[i] != NULL) Delete(rt->next[i]);
    }
    delete rt;
    rt = NULL;
}

int main(){
    char s[15];
    root = new Trie();
    for(int i = 0; i < MAX; i++)
        root->next[i] = NULL;
    int kase = 1,flag = 1;
    while(scanf("%s", s) != EOF){
        if(s[0] == '9'){
            if(flag == 1)
                printf("Set %d is immediately decodable\n", kase++);
            else
                printf("Set %d is not immediately decodable\n", kase++);
            Delete(root);
            flag = 1;
            root = new Trie();
            for(int i = 0; i < MAX; i++)
                root->next[i] = NULL;
        }
        if(!Insert(s)) flag = 0;

    }
    return 0;
}

HDU 1075 What Are You Talking About

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX  26

struct Trie{
    int val;
    char str[12];
    Trie *next[MAX];
};

Trie *root;

void Insert(char *s1, char *s2){
    int n = strlen(s1);
    Trie *pre = root, *cur;
    for(int i = 0; i < n; i++){
        int id = s1[i]-'a';
        if(pre->next[id] == NULL){
            cur = new Trie();
            cur->val = 0;
            for(int j = 0; j < MAX; j++) cur->next[j] = NULL;
            pre->next[id] = cur;
        }
        pre = pre->next[id];
    }
    pre->val = 1;
    strcpy(pre->str, s2);
}

bool Search(char *s, char *ans){
    Trie *pre = root;
    int n = strlen(s);
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL) return false;
        pre = pre->next[id];
    }
    if(pre->val){
        strcpy(ans, pre->str);
        return true;
    }
    return false;
}

void Delete(Trie *rt){
    if(NULL == rt) return ;
    for(int i = 0; i < MAX; i++)
        if(rt->next[i] != NULL) Delete(rt->next[i]);
    delete rt;
    rt = NULL;
}

char s[3005],s1[12],s2[12],ans[12],temp[12];

int main(){
    root = new Trie();
    for(int i = 0; i < MAX; i++) root->next[i] = NULL;
    while(scanf("%s", s1) != EOF){
        if(s1[0] == 'S') continue;
        if(s1[0] == 'E'){
            getchar();
            while(gets(s)){
                if(s[0] == 'S') continue;
                if(s[0] == 'E'){
                    Delete(root);
                    root = new Trie();
                    for(int i = 0; i < MAX; i++) root->next[i] = NULL;
                    break;
                }
                int i,j,len = strlen(s);
                for(i = 0; i < len; i++){
                    if(s[i] >= 'a' && s[i] <= 'z'){
                        for(j = i; j < len; j++)
                            if(s[j] < 'a' || s[j] > 'z') break;
                        int cnt = 0;
                        for(int k = i; k < j; k++)
                            temp[cnt++] = s[k];
                        temp[cnt] = '\0';
                        if(Search(temp,ans)) printf("%s", ans);
                        else printf("%s", temp);
                        i = j-1;
                    }
                    else printf("%c", s[i]);
                }
                printf("\n");
            }
        }
        scanf("%s", s2);
        Insert(s2,s1);
    }
    return 0;
}

HDU 1247 Hat’s Words

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 26
char s[50005][105],s1[105],s2[105];

struct Trie{
    int val;
    Trie *next[MAX];
};

Trie *root;

void Insert(char *s){
    int n = strlen(s);
    Trie *pre = root,*cur;
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL){
            cur = new Trie();
            cur->val = 0;
            for(int j = 0; j < MAX; j++) cur->next[j] = NULL;
            pre->next[id] = cur;
        }
        pre = pre->next[id];
    }
    pre->val = 1;
}

bool Search(char *s){
    int n = strlen(s);
    Trie *pre = root;
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL) return false;
        pre = pre->next[id];
    }
    if(pre->val) return true;
    else return false;
}

void solve(char s[50005][105],int n){
    for(int i = 0; i < n; i++){
        int m = strlen(s[i]);
        for(int j = 1; j < m; j++){
            memset(s1, '\0', sizeof(s1));
            memset(s2, '\0', sizeof(s2));
            strncpy(s1, s[i], j);
            strcpy(s2, s[i]+j);
            if(Search(s1) && Search(s2)){
                printf("%s\n", s[i]);
                break;
            }
        }
    }
}

void Delete(Trie *rt){
    if(NULL == rt) return ;
    for(int i = 0; i < MAX; i++) Delete(rt->next[i]);
    delete rt;
    rt = NULL;
}

int main(){
    int i = 0;
    root = new Trie();
    root->val = 0;
    for(int j = 0; j < MAX; j++) root->next[i] = NULL;
    while(scanf("%s", s[i]) != EOF){
        Insert(s[i]);
        i++;
    }
    solve(s, i);
    Delete(root);
    return 0;
}

HDU 1671 Phone List

> 静态建树

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;

const int maxnode = 500000;
const int sigma_size = 11;

struct Trie
{
    int ch[maxnode][sigma_size];
    int val[maxnode];
    int sz;
    Trie()
    {
        sz = 1 ;
        memset(ch[0],0,sizeof(ch[0]));
    }
    int idx(char c)
    {
        return c - '0';
    }
    int Insert(char *s)
    {
        int u = 0,n = strlen(s);
        int flag;
        for(int i = 0;i < n ;i++)
        {
            int c = idx(s[i]);
            flag = 1;
            if(!ch[u][c])
            {
                flag = 0;
                memset(ch[sz],0,sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
            if(val[u]) return 0;
        }
        if(flag) return 0;
        val[u] = 1;
        return 1;
    }
    void Delete()
    {
        memset(ch,0,sizeof(ch));
        memset(val,0,sizeof(val));
        sz = 1 ;
    }
};
char s[45];
Trie tree;
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int N;
        scanf("%d",&N);
        int flag = 1;
        while(N--)
        {
            scanf("%s",s);
            if(tree.Insert(s) == 0)
                flag = 0;
        }
        tree.Delete();
        if(flag)  printf("YES\n");
        else   printf("NO\n");
    }
}

动态建树

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 10

struct Trie{
    int val;
    Trie *next[MAX];
};

Trie *root;

bool Insert(char *s){
    int n = strlen(s);
    Trie *pre = root,*cur;
    int flag = 1;
    for(int i = 0; i < n; i++){
        int id = s[i] - '0';
        if(pre->next[id] == NULL){
            flag = 0;
            cur = new Trie();
            cur->val = 0;
            for(int j = 0; j < MAX; j++) cur->next[j] = NULL;
            pre->next[id] = cur;
            pre = pre->next[id];
        }
        else{
            pre = pre->next[id];
            if(pre->val) return false;
        }
    }
    pre->val = 1;
    if(flag) return false;
    else return true;
}

void Delete(Trie *rt){
    if(NULL == rt) return ;
    for(int i = 0; i < MAX; i++){
        if(rt->next[i] != NULL) Delete(rt->next[i]);
    }
    delete rt;
    rt = NULL;
}

int main(){
    char s[15];
    int T,n;
    scanf("%d", &T);
    while(T--){
        root = new Trie();
        for(int i = 0; i < MAX; i++)
            root->next[i] = NULL;
        scanf("%d", &n);
        int flag = 1;
        while(n--){
            scanf("%s", s);
            if(!Insert(s)) flag = 0;
        }
        if(flag) printf("YES\n");
        else printf("NO\n");
        Delete(root);
    }
    return 0;
}

HDU 2846 Repository

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 26

struct Trie{
    int val,flag;
    Trie *next[MAX];
};

Trie *root;

void Insert(char *s, int log){
    int n = strlen(s);
    for(int i = 0; i < n; i++){
        Trie *pre = root, *cur;
        for(int j = i; j < n; j++){
            int id = s[j] - 'a';
            if(pre->next[id] == NULL){
                cur = new Trie();
                cur->val = 1;
                cur->flag = log;
                for(int k = 0; k < MAX; k++) cur->next[k] = NULL;
                pre->next[id] = cur;
                pre = pre->next[id];
            }
            else{
                pre = pre->next[id];
                if(pre->flag != log){
                    pre->flag = log;
                    pre->val++;
                }
            }
        }
    }
}

int Search(char *s){
    int n = strlen(s);
    Trie *pre = root;
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL) return 0;
        pre = pre->next[id];
    }
    return pre->val;
}

void Delete(Trie *rt){
    if(rt == NULL) return ;
    for(int i = 0; i < MAX; i++)
        if(rt->next[i] != NULL) Delete(rt->next[i]);
    delete rt;
    rt = NULL;
}

char s[25];

int main(){
    root = new Trie();
    root->val = 0;
    for(int i = 0; i < MAX; i++) root->next[i] = NULL;
    int P,Q;
    scanf("%d", &P);
    for(int i = 1; i <= P; i++){
        scanf("%s", s);
        Insert(s, i);
    }
    scanf("%d", &Q);
    while(Q--){
        scanf("%s", s);
        printf("%d\n", Search(s));
    }
    Delete(root);
    return 0;
}

HDU 5687 Problem C

#include <cstdio>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int maxnode = 3000000;
const int sigma_size = 27;

struct Node
{
    int x,y;
    Node(int a,int b):x(a),y(b){}
    Node() {}
};

struct Trie
{
    int ch[maxnode][sigma_size];
    int val[maxnode];
    int sz;
    Trie() {sz = 1; memset(ch[0], 0, sizeof(ch[0]));}
    int idx(char c) {return c - 'a';}
    void Insert(char *s)
    {
        int u = 0, n = strlen(s);
        for(int i = 0; i < n; i++)
        {
            int c = idx(s[i]);
            if(!ch[u][c])
            {
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 1;
                ch[u][c] = sz++;
                u = ch[u][c];
            }
            else
            {
                u = ch[u][c];
                val[u]++;
            }
        }
    }

    bool Search(char *s)
    {
        int u = 0,n = strlen(s);
        for(int i = 0; i < n; i++)
        {
            int c = idx(s[i]);
            if(!ch[u][c])
                return false;
            else u = ch[u][c];
        }
        return true;
    }

    void Delete(char *s)
    {
        stack <Node> S;
        while(!S.empty()) S.pop();
        int u = 0,n = strlen(s),f,c;
        for(int i = 0; i < n; i++)
        {
            c = idx(s[i]);
            S.push(Node(u,c));
            if(!ch[u][c])
                return;
            else
            {
                f = u;
                u = ch[u][c];
            }
        }
        ch[f][c] = 0;
        if(val[f] - val[u] == 0)
        {
            S.pop();
            while(!S.empty())
            {
                Node node = S.top();
                S.pop();
                int temp = ch[node.x][node.y];
 //               printf("%d %d\n", node.x,node.y);
                if(val[temp] - val[u]) break;
                else ch[node.x][node.y] = 0;
            }
        }
    }
};

Trie tree;

int main()
{
    int N;
    scanf("%d", &N);
    char op[10],s[35];
    while(N--)
    {
        scanf("%s %s", op, s);
        if(op[0] == 'i')
            tree.Insert(s);
        else if(op[0] == 's')
        {
            if(tree.Search(s)) printf("Yes\n");
            else printf("No\n");
        }
        else if(op[0] == 'd')
            tree.Delete(s);
    }
    return 0;
}

POJ 2503 Babelfish

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX  26

struct Trie{
    int val;
    char str[15];
    Trie *next[MAX];
};

Trie *root;

void Insert(char *s1, char *s2){
    int n = strlen(s1);
    Trie *pre = root, *cur;
    for(int i = 0; i < n; i++){
        int id = s1[i]-'a';
        if(pre->next[id] == NULL){
            cur = new Trie();
            cur->val = 0;
            for(int j = 0; j < MAX; j++) cur->next[j] = NULL;
            pre->next[id] = cur;
        }
        pre = pre->next[id];
    }
    pre->val = 1;
    strcpy(pre->str, s2);
}

bool Search(char *s, char *ans){
    Trie *pre = root;
    int n = strlen(s);
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL) return false;
        pre = pre->next[id];
    }
    if(pre->val){
        strcpy(ans, pre->str);
        return true;
    }
    return false;
}

char s[35],s1[15],s2[15],ans[15];

int main(){
    root = new Trie();
    for(int i = 0; i < MAX; i++) root->next[i] = NULL;
    while(gets(s) && strcmp(s, "")){
        for(int i = 0; i < (int)strlen(s); i++){
            if(s[i] == ' '){
                strcpy(s2, s+i+1);
                strncpy(s1, s, i);
                Insert(s2, s1);
                break;
            }
        }
    }
    while(gets(s) != NULL){
        if(Search(s, ans))
            printf("%s\n", ans);
        else
            printf("eh\n");
    }
    return 0;
}

POJ 2001 Shortest Prefixes

#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 26

struct Trie{
    int val;
    Trie *next[MAX];
};

Trie *root;

void Insert(char *s){
    int n = strlen(s);
    Trie *pre = root, *cur;
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        if(pre->next[id] == NULL){
            cur = new Trie();
            cur->val = 1;
            for(int j = 0; j < MAX; j++) cur->next[j] = NULL;
            pre->next[id] = cur;
            pre = pre->next[id];
        }
        else{
            pre = pre->next[id];
            pre->val++;
        }
    }
}

void Search(vector<char>& ans, char *s){
    int n = strlen(s);
    Trie *pre = root;
    for(int i = 0; i < n; i++){
        int id = s[i] - 'a';
        ans.push_back(s[i]);
        pre = pre->next[id];
        if(pre->val == 1) break;
    }
}

void Delete(Trie *rt){
    if(NULL == rt) return ;
    for(int i = 0; i < MAX; i++)
        if(rt->next[i] != NULL) Delete(rt->next[i]);
    delete rt;
    rt = NULL;
}

char s[1005][25];
vector <char> ans;

int main(){
    int i = 0;
    root = new Trie();
    root->val = 0;
    for(int j = 0; j < MAX; j++) root->next[j] = NULL;
    while(scanf("%s", s[i]) != EOF){
        Insert(s[i++]);
    }
    for(int j = 0; j < i; j++){
        ans.clear();
        Search(ans, s[j]);
        printf("%s ", s[j]);
        for(int k = 0; k < ans.size(); k++)
            printf("%c", ans[k]);
        printf("\n");
    }
    Delete(root);
    return 0;
}
TouchDreamer
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字典树题目总结
天亮说晚安
02-17 3717
Trie 就好比维护了一个字典，可以在这个字典里插入删除字符串，也可以查询一个字符串是否在字典中。Trie的插入查找删除复杂度都是O(m)的，其中m为待插入串的长度。 Trie的原理是利用字符串集合中字符串的公共前缀来降低时间开销以达到提高效率的目的。 HDU1251-统计难题： 最简单的字典树题，对于字典中的字符串插入后依次回答询问子串个数即可。 解题报告
字典树的题目 找了个时间刷了一点字典树的题目
sdut_jean的博客
04-26 1235
http://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Contest/contestproblem/cid/2009/pid/2828 #include #include #include #include #include using namespace std; struct node { int v; node
/*字典树*/一些简单题
生成猫
07-30 310
奇数位回文字串 先看字典树的东西：
字典树入门和例题
一只不争气的蒸汽机的博客
01-29 577
视频讲解戳这里 何为字典树： 如图所示： 每个字符有很多个分支，打黄色标记的就是字符串的结尾，所以这颗字典树中有哪些字符串呢，"ab","ay","ayf","c","cc","cd",其他的枝没有画全。 如何存储： 顺序存储字符串：“ab”“ay”“ayf”“c”“cc”“cd”……(节点编号讲究先到先得) 数组tree[i][j]:代表i节点的第j个儿子的节点编号。...
字典树（Trie树）模板以及简单的入门题总结
热门推荐
lajiyuan的博客
06-05 1万+
字典树模板 const int maxn =2e6+5;//如果是64MB可以开到2e6+5，尽量开大 int tree[maxn][30];//tree[i][j]表示节点i的第j个儿子的节点编号 bool flagg[maxn];//表示以该节点结尾是一个单词 int tot;//总节点数 void insert_(char *str) { int len=strlen(str)...
字典树基础与应用
weixin_44858814的博客
01-06 1037
一个节点的所有子孙具有相同的前缀，也就是这个节点代表的字符串，根节点代表空字符串。时，就不会继续往下比较了，因为不管后面是什么结果，a异或b的结果都会比c小。从左往右比较，当比较到第3位时，异或结果是比x小的，所以后面就不用比较了。从字典树的根开始遍历，向下查找字符串的插入位置，并记录满足条件的前缀数量。，两两取异或，根据异或结果计数，这是我第一次写的代码，毫无疑问超时了。其中的键通常是字符串，由节点在树中的位置决定，键保存在。每遍历一个节点，不管节点是否存在，节点的。，我们从高位往低位比较，当找到一个。
数据结构基础19：字典树
何哥的博客
02-03 459
前言：字典树（Trie）可以保存一些字符串-&gt;值的对应关系。基本上，它跟 Java 的 HashMap 功能相同，都是 key-value 映射，只不过 Trie 的 key 只能是字符串。Trie 的强大之处就在于它的时间复杂度。它的插入和查询时间复杂度都为 O(k) ，其中 k 为 key 的长度，与 Trie 中保存了多少个元素无关。Hash 表号称是 O(1) 的，但在计算 hash...
面试常见基础算法题总结
04-29
15. **字典树（Trie）**：用于字符串搜索和统计，每个节点对应一个字符，便于快速插入和查找前缀。 16. **全排列**：通过递归实现，回溯过程中需要恢复原始数组状态。 17. **N个骰子出现和为m的概率**：可以用动态...
16-字典树.pdf
02-24
1. 实现前缀树（Trie）：在LeetCode上寻找实现字典树相关的练习题，题号为[实现前缀树](***。 2. 单词搜索II：同样是LeetCode上的题目，涉及到在一个二维网格中寻找单词，题号为[单词搜索II](***。 在系统设计领域...
软件工程基础试题精.doc
最新发布
07-29
【软件工程基础试题解析】 1. 需求获取、需求分析、编写需求规格说明书以及需求审评是软件需求分析阶段的主要工作。需求获取是理解用户需求，需求分析是将需求转化为可操作的规格，编写需求规格说明书是明确记录...
Python工程师面试题 与Python基础语法相关
09-21
### Python工程师面试题与Python基础语法相关知识点详解 #### 一、Pass语句的作用 - **定义**: `pass` 是Python中的一个空语句，它不会执行任何操作。 - **应用场景**: - 作为占位符：在代码设计阶段，如果某个...
计算机软件基础自考试题.pdf
11-08
【计算机软件基础自考试题解析】 1. 系统软件包括操作系统、数据库系统、网络软件等，用于管理和控制计算机硬件资源，提供用户与硬件交互的接口。例如，B选项的操作系统就是系统软件的一个典型代表。 2. 在单链表...
trie树 mysql_Trie树详解（转）
weixin_36164428的博客
01-30 173
特别声明本文只是一篇笔记类的文章，所以不存在什么抄袭之类的。以下为我研究时参考过的链接(有很多，这里我只列出我记得的)：1、字典树的概念字典树，因为它的搜索快捷的特性被单词搜索系统使用，故又称单词查找树。它是一种树形结构的数据结构。之所以快速，是因为它用空间代替了速度。2、字典树的特点：字典树有三个基本性质：1、根节点不包含字符，除根节点外每一个节点都只包含一个字符2、从根节点到某一个节点，路径上...
POJ 【1088】 滑雪
你真的介意真的在乎真的想要真的渴望的话你一定能够做到
04-27 4067
滑雪 Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 88858   Accepted: 33341 Description Michael喜欢滑雪百这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等
博弈论习题集（由易到难）
你真的介意真的在乎真的想要真的渴望的话你一定能够做到
08-20 2701
博弈论习题集（由易到难） 在做题目之前如果一点也不懂还需要看一下博弈论的基础知识三大基础博弈 HDU 1846 Brave Game#include <cstdio> #include <cstring> #include <iostream> #include <algorithm> using namespace std; typedef long long LL;int read(){
POJ Space Elevator(排序+多重背包)
你真的介意真的在乎真的想要真的渴望的话你一定能够做到
10-31 557
题目分析 好久没有写背包了，因此找了一个多重背包练一下，因为多重背包是01背包和完全背包的结合，手生，写了有一会！！！ 就是给你一下砖块，每一个砖块一个高度，给出数量和这样砖块最多能放的高度。。 这道题因为每个点的限制不一样，所以需要从限制小的先进行dp，因为限制大的可以放在限制小的上面，但是限制小的无法再往大的上面堆，这样就算错了。。 #include <cstdio> #incl
POJ 2923 Relocation(状态压缩+背包思想)
你真的介意真的在乎真的想要真的渴望的话你一定能够做到
10-31 528
题目分析 因为是判断2辆车能够运多少次才能把所有的物品给运完，因为物品数不够多，因此可以枚举状态，判断每个状态能否由2辆车给运完，这里面可以用01背包的思想进行判断，然后自己就可以通过状态压缩写出状态转移方程，很明显dp[(1<<n)−1]dp[(1<<n)-1]就是答案。 #include <cstdio> #include <cstring> #include <iostream> #inc
POJ 3279 Fliptile
你真的介意真的在乎真的想要真的渴望的话你一定能够做到
04-30 469
到此[kuangbin带你飞]专题一 简单搜索所有的题已经被我全部写完，感觉有些题不是那么好做，继续努力吧！！同时给出地址，学习搜索的也可以经常到上面刷题。 [kuangbin带你飞]专题一 简单搜索 题目大意 给出一个长方形，让你点击其中的若干块，使得所有的方块全部翻转为白色，同时点击一块方块同时会使它相邻的方块也会翻转过来。 题目解法 利用状态压缩枚举第一行所有可能的翻转情
POJ【2031】Building a Space Station
你真的介意真的在乎真的想要真的渴望的话你一定能够做到
01-11 458
Building a Space Station Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 6439   Accepted: 3162 Description You are a member of the space station engineering te
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值