搜索——洛谷P1013 进制位

https://www.luogu.org/problem/show?pid=1013#sub
这个题的关键;
首先,不可能输入只有个位数
因为两个非零个位数相加答案是一个新的个位数;
既然有两位数,那么1一定存在;
既然1一定存在,那么2一定存在;
以此类推,最后会发现空一个数,就是0;
所以进制一定是确定的;
直接全排列暴搜走起

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<cstdio>
using namespace std;
map<char,int>F;
char c[100],cc,s[100];
int a[100][100][40],v[100];
int n;
int find(int x,int y){
    int ans=v[a[x][y][1]];
    if(a[x][y][0]==2)ans=ans*(n-1)+v[a[x][y][2]];
    return ans;
}
bool check(){
    for(int i=1;i<n;i++)
    for(int j=1;j<n;j++)
        if(v[i]+v[j]!=find(i,j))return 0;
    return 1;
}
void out(){
    for(int i=1;i<n;i++)printf("%c=%d ",c[i],v[i]);
    printf("\n%d",n-1);
    exit(0);    
}
void dfs(int k){
    if(k==n-1)if(check())out();else;else;
        for(int i=1;i<n;i++)if(v[i]==-1)v[i]=k,dfs(k+1),v[i]=-1;
}
int main()
{
    scanf("%d",&n);
    cin>>cc;
    for(int i=1;i<n;i++){
        cin>>cc;
        F[cc]=i;c[i]=cc;
    }
    for(int i=1;i<n;i++){
        cin>>cc;
        for(int j=1;j<n;j++){
            scanf("%s",s+1);
            a[i][j][0]=strlen(s+1);
            for(int k=1;k<=a[i][j][0];k++)a[i][j][k]=F[s[k]];
        }
    }
    memset(v,-1,sizeof v);
    dfs(0);
    cout<<"ERROR!"<<endl;
}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态二进制树形搜索算法(Dynamic Binary Tree Search Algorithm)是一种常用的防碰撞算法,它通过将标签ID进行二进制拆分,将标签按照不同的二进制存储在不同的树节点中,实现快速的标签识别和查询。下面我将为您介绍如何设计和实现该算法。 1. 算法设计 (1)确定树的结构:动态二进制树形搜索算法是一种树形搜索算法,因此需要确定树的结构。一般来说,可以采用二叉树或四叉树。二叉树每个节点最多有两个子节点,而四叉树每个节点最多有四个子节点。在实际应用中,根据标签量和查询效率的要求,可以选择不同的树结构。 (2)确定节点存储方式:对于每个节点,需要存储其对应的二进制和存储的标签信息。一般来说,可以采用组或链表等据结构进行存储。 (3)标签插入:当一个新的标签需要插入时,需要按照其二进制形式逐级向下搜索树,直到找到一个空闲的节点,然后将标签信息存储在该节点上。 (4)标签查询:当需要查询一个标签时,需要按照其二进制形式逐级向下搜索树,直到找到一个节点,该节点存储了该标签信息或者没有子节点。如果找到了该标签信息,则查询成功,否则查询失败。 (5)树的更新:当一个标签需要从树中删除时,需要依次向上搜索其所有的祖先节点,并检查这些节点是否还有其他子节点。如果某个节点已经没有子节点,则将该节点从树中删除。 2. 算法实现 下面是动态二进制树形搜索算法的C++实现代码: ```cpp #include <iostream> #include <vector> #include <bitset> using namespace std; // 树节点结构体 struct TreeNode { int depth; // 节点深度 int tag; // 标签信息 TreeNode* left; // 左子节点 TreeNode* right; // 右子节点 TreeNode(int depth, int tag) { this->depth = depth; this->tag = tag; this->left = NULL; this->right = NULL; } }; // 二进制转换为字符串 string toBinaryString(int num) { bitset<32> bits(num); return bits.to_string(); } // 插入标签 void insertTag(TreeNode* root, int tag) { string tagStr = toBinaryString(tag); TreeNode* curNode = root; for (int i = 0; i < tagStr.length(); i++) { if (tagStr[i] == '0') { if (curNode->left == NULL) { curNode->left = new TreeNode(i, -1); } curNode = curNode->left; } else { if (curNode->right == NULL) { curNode->right = new TreeNode(i, -1); } curNode = curNode->right; } } curNode->tag = tag; } // 查询标签 bool searchTag(TreeNode* root, int tag) { string tagStr = toBinaryString(tag); TreeNode* curNode = root; for (int i = 0; i < tagStr.length(); i++) { if (tagStr[i] == '0') { if (curNode->left == NULL) { return false; } curNode = curNode->left; } else { if (curNode->right == NULL) { return false; } curNode = curNode->right; } } return curNode->tag == tag; } // 删除标签 void deleteTag(TreeNode* root, int tag) { string tagStr = toBinaryString(tag); vector<TreeNode*> path; TreeNode* curNode = root; for (int i = 0; i < tagStr.length(); i++) { path.push_back(curNode); if (tagStr[i] == '0') { curNode = curNode->left; } else { curNode = curNode->right; } } curNode->tag = -1; for (int i = path.size() - 1; i >= 0; i--) { if (path[i]->left == NULL && path[i]->right == NULL) { if (i == 0) { delete root; root = NULL; } else { if (path[i-1]->left == path[i]) { delete path[i-1]->left; path[i-1]->left = NULL; } else { delete path[i-1]->right; path[i-1]->right = NULL; } } } else { break; } } } int main() { TreeNode* root = new TreeNode(0, -1); insertTag(root, 10); insertTag(root, 5); insertTag(root, 15); insertTag(root, 12); insertTag(root, 20); cout << searchTag(root, 10) << endl; // 1 cout << searchTag(root, 7) << endl; // 0 deleteTag(root, 20); cout << searchTag(root, 20) << endl; // 0 return 0; } ``` 在该实现中,我们使用了二叉树作为树的结构,使用了组来存储每个节点的信息。具体实现过程如下: (1)我们先定义了一个TreeNode结构体,它包含了节点的深度、标签信息和左右子节点。 (2)我们使用了toBinaryString函将一个十进制转换成二进制字符串。 (3)我们定义了insertTag函,它将标签插入到树中。具体实现过程是,按照标签的二进制形式逐级向下搜索树,并在找到一个空闲的节点时将标签信息存储在该节点上。 (4)我们定义了searchTag函,它用于查询一个标签。具体实现过程是,按照标签的二进制形式逐级向下搜索树,如果找到了标签信息,则查询成功,否则查询失败。 (5)我们定义了deleteTag函,它用于删除一个标签。具体实现过程是,先查询到该标签所在的节点,将该节点的标签信息置为-1,然后从该节点向上依次检查其所有的祖先节点,如果某个节点已经没有子节点,则将该节点从树中删除。 3. 总结 动态二进制树形搜索算法是一种常用的防碰撞算法,它可以快速地插入、查询和删除标签。在实际应用中,我们可以根据标签量和查询效率的要求,选择不同的树结构和节点存储方式。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值