精华内容
下载资源
问答
  • 网络游戏-入侵检测系统中基于多属性哈希去重的网络日志存储方法.zip
  • 在接触到对象之后,才发现,对象的真正的强大之处,而这个hash(哈希)数组去重的算法就是利用对象的一些特点进行编写的。上代码。 <!DOCTYPE html> <html lang="en"...

    在接触一门语言一段时间之后,就一定得去积累一些常用的算法,今天来和大家分享一个数组去重的算法——hash去重。

    以前在实现js的一些算法问题的时候还是用c的一些基础的编程思想来解决问题。在接触到对象之后,才发现,对象的真正的强大之处,而这个hash(哈希)数组去重的算法就是利用对象的一些特点进行编写的。上代码。

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>hash数组去重</title>
    </head>
    <body>
        <script>
        //随便键入一些数字,将其存在数组中
        var arr = [1,1,1,2,2,2,3,3,3,4,4,5,6,2,3,4];
        //在数组原型上改变数组去重的方法
        Array.prototype.unique = function () {
            //定义一个空数组,用来将去重结束后的结果返回
            var arr = [];
            //定义一个空对象,用来判断数组中的数字中是否有这个对象的属性,(判断的条件)
            var obj = {};
            //定义一个length,用来做循环的判断条件
            var length = this.length;
            //循环遍历数组中的每个对象
            for(var i = 0; i < length; i ++){
                //判断obj这个对象上有没有数组对应数字的属性名称
                if(obj[this[i]] == undefined){
                    //如果没有对象数组中数字的属性名称,就创建这个属性,并且添加属性内容
                    obj[this[i]] = this[i];
                    //将这个属性(也就是数字)push到这个新的arr数组中
                    arr.push(this[i]);
                }
            }
            //返回去重结束后的这个数组
            return arr;
        }
        </script>
        
    </body>
    </html>

     

    这种使用判断对象属性名称是否存在(有则添加,无则忽视),从而通过添加数组中内容的思想还是比较新颖的。利用对象的一些属性进行功能的实现,

    展开全文
  • 八数码问题之哈希去重: 输入: 2 6 4 1 3 7 0 5 8 8 1 5 7 3 6 4 0 2 输出: 31 */ /* 关键: 1 哈希:把结点变成整数,但不必是一一对应。设计一个哈希函数h(x),然后将任意结点x映射到某个给定的范围[0,M-1...
    /*
    八数码问题之哈希去重:
    输入:
    2 6 4 1 3 7 0 5 8
    8 1 5 7 3 6 4 0 2
    输出:
    31
    */
    
    /*
    关键:
    1 哈希:把结点变成整数,但不必是一一对应。设计一个哈希函数h(x),然后将任意结点x映射到某个给定的范围[0,M-1]的整数即可,其中M是程序员根据可用内存大小
    自选的。不同结点哈希值相同时,用链表组织哈希值相同的链表。
    2 iSum = 10 * iSum + s[i];//把9个数字组成九位数,妙哉
    3 return iSum % MAXHASHSIZE;//确保hash函数值不超过hash表的大小的非负整数这里除数尽量取大质数
    4 	int h = hash(st[x]);//求第x个状态组对应的哈希值
    	int u = iHead[h];//向获取每条链中的链首值
    	while(u)//这个while的作用是遍历具有相同哈希值的一条链,如果能找到,说明插入失败,如果找不到,则采用头插法插入新来的节点
    	{
    		if(memcmp(st[u],st[x],sizeof(st[x])) == 0)//如果发现经过哈希值计算中的某个结点与源节点相同,说明之前已经有过该状态值,此时该状态相当于已访问
    		{
    			return false;
    		}
    		u = iNext[u];
    	}
    	iNext[x] = iHead[h];//采用头插法,获取头结点的指向
    	iHead[h] = x;//将链中加入第x个状态编号
    */
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    const int MAXSIZE = 1000000;
    typedef int State[9];
    State st[MAXSIZE],stEnd;
    const int MAXHASHSIZE = 100003;
    int iHead[MAXHASHSIZE];
    int iNext[MAXSIZE];
    int iDist[MAXSIZE];
    int go[][2] = 
    {
    	{-1,0},
    	{1,0},
    	{0,-1},
    	{0,1}
    };
    
    int hash(State& s)
    {
    	int iSum = 0;
    	for(int i = 0 ; i < 9 ; i++)
    	{
    		iSum = 10 * iSum + s[i];//把9个数字组成九位数,妙哉
    	}
    	return iSum % MAXHASHSIZE;//确保hash函数值不超过hash表的大小的非负整数这里除数尽量取大质数
    }
    
    bool isInsert(int x)
    {
    	int h = hash(st[x]);//求第x个状态组对应的哈希值
    	int u = iHead[h];//向获取每条链中的链首值
    	while(u)//这个while的作用是遍历具有相同哈希值的一条链,如果能找到,说明插入失败,如果找不到,则采用头插法插入新来的节点
    	{
    		if(memcmp(st[u],st[x],sizeof(st[x])) == 0)//如果发现经过哈希值计算中的某个结点与源节点相同,说明之前已经有过该状态值,此时该状态相当于已访问
    		{
    			return false;
    		}
    		u = iNext[u];
    	}
    	iNext[x] = iHead[h];//采用头插法,获取头结点的指向
    	iHead[h] = x;//将链中加入第x个状态编号
    	return true;
    }
    
    
    int bfs()
    {
    	int iFront = 1,iRear = 2;
    	memset(iHead,0,sizeof(iHead));
    	while(iFront < iRear)
    	{
    		State& state = st[iFront];
    		if(memcmp(stEnd,state,sizeof(state)) == 0)
    		{
    			return iFront;
    		}
    		int iX,iY,iZ;
    		for(iZ = 0 ; iZ < 9 ; iZ++)
    		{
    			if(!state[iZ])
    			{
    				break;
    			}
    		}
    		iX = iZ / 3;
    		iY = iZ % 3;
    		int iNewZ,iNewX,iNewY;
    		for(int i = 0 ; i < 4; i++)
    		{
    			iNewX = go[i][0] + iX;
    			iNewY = go[i][1] + iY;
    			iNewZ = iNewX * 3 + iNewY;
    			if(iNewX >= 0 && iNewX < 3 && iNewY >= 0 && iNewY < 3)
    			{
    				State& newState = st[iRear];
    				memcpy(&newState,&state,sizeof(state));
    				newState[iNewZ] = state[iZ];
    				newState[iZ] = state[iNewZ];
    				iDist[iRear] = iDist[iFront] + 1;
    				if(isInsert(iRear))
    				{
    					iRear++;
    				}
    			}
    		}
    		iFront++;
    	}
    	return -1;
    }
    
    void process()
    {
    	iDist[1] = 0;
    	for(int i = 0; i < 9; i++)
    	{
    		scanf("%d",&st[1][i]);
    	}
    	for(int j = 0 ; j < 9 ; j++)
    	{
    		scanf("%d",&stEnd[j]);
    	}
    	int iRes = bfs();
    	if(iRes > 0)
    	{
    		printf("%d\n",iDist[iRes]);
    	}
    	else
    	{
    		printf("-1\n");
    	}
    }
    
    int main(int argc,char* argv[])
    {
    	process();
    	system("pause");
    	return 0;
    }
    

    展开全文
  • 题解:这是一道枚举+组合的题目,可以用回溯法得到所有的组合情况,只不过序列中存在重复数字,我们需要哈希表来达到去重的目的,具体的做法就是用哈希表记录序列中每个数字的重复个数作为该数字可出现的次数,回溯...

    给定一个可包含重复数字的序列,返回所有不重复的全排列。

    示例:
    输入: [1,1,2]
    输出:
    [
    [1,1,2],
    [1,2,1],
    [2,1,1]
    ]

    题解:这是一道枚举+组合的题目,可以用回溯法得到所有的组合情况,只不过序列中存在重复数字,我们需要哈希表来达到去重的目的,具体的做法就是用哈希表记录序列中每个数字的重复个数作为该数字可出现的次数,回溯的过程中要实时更新哈希表,如果回溯的过程中选择了某个数字,则将这个数字在哈希表中对应的可出现次数减1,如果该数字的可出现次数的值变为0,则不能再选择该数字。

    class Solution {
        Stack<Integer>stack=new Stack<>();
        List<List<Integer>>res=new ArrayList<>();
        public List<List<Integer>> permuteUnique(int[] nums) {
               Map<Integer,Integer>map=new HashMap<>();
               for(int x:nums){
                   map.put(x,map.getOrDefault(x,0)+1);
               }
               Set<Integer>keySet=map.keySet();
               backTrace(map,keySet, nums.length);
               return res;
        }
        private void backTrace(Map<Integer,Integer>map,Set<Integer>keySet,int len){
            if (stack.size()==len){
                res.add(new ArrayList<>(stack));
                return;
            }
            for(int x:keySet){
                if(map.get(x)>0){
                    map.put(x,map.get(x)-1);
                    stack.push(x);
                    backTrace(map,keySet,len);
                    stack.pop();
                    map.put(x,map.get(x)+1);
                }
            }
        }
    }
    
    展开全文
  • g 是一个用来存储字符串、具有去重功能的容器,即相同字符串在 g 中只能保留一个。两个字符串相等,当且仅当,长度一样且对应位置的字符都一样。韩爷前晚没睡好,随手写了一个程序交给面试官,然后就gg了。...

    一天,韩爷去百度面试,面试官给了他这么一个问题。

    给你2万个字符串,每个字符串长度都是100,然后把2万个字符串丢入一个 set< string >g 中,问最终set里含有多少个元素?

    g 是一个用来存储字符串、具有去重功能的容器,即相同字符串在 g 中只能保留一个。

    两个字符串相等,当且仅当,长度一样且对应位置的字符都一样。

    韩爷前晚没睡好,随手写了一个程序交给面试官,然后就gg了。

    #include<iostream>
    #include<string>
    #include<set>
    using namespace std;
    string s;
    set<string>g;
    int main(){
        for(int k=1;k<=20000;k++){
            cin>>s;
            g.insert(s);
        }
        cout<<g.size()<<endl;
        return 0;
    }

    韩爷醒来之后,发现这只是一个梦(还好只是个梦)。他回忆起梦中的面试官给他的内存限制和时间限制非常低,这么做肯定过不了,那么,现在你不在梦中,你能解决这个问题么?

    Input
    单case

    每个case有且只有2万行,每一行包含一个字符串,每行字符串的长度都为100 (样例除外)

    字符集:大写英文字母(A-Z),小写英文字母(a-z),数字(0-9)

    Output
    输出一个整数,表示最终set里含有多少个元素。

    Sample Input
    aaAa
    aaAa
    bbbb
    1234
    bbbb
    bbbb
    ee09
    Sample Output
    4
    Hint
    样例只是样例,不在test中

    注意时间限制和内存限制非常低

    分析:就是求集合的大小,关键在于时间和内存, 这里就用哈希表和unique()函数解决

    #include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <cmath>
    #include <algorithm>
    #include <sstream>
    #include <string>
    #include <set>
    #include <map>
    #include <queue>
    using namespace std;
    #define mem(a,n) memset(a,n,sizeof(a))
    #define pb(x) push_back(x)
    typedef long long LL;
    typedef unsigned long long ull;
    const int mod=1e9+7;
    const double eps=1e-6;
    const int INF=0x3f3f3f3f;
    const int N=2e4+5;
    LL vis[N];
    LL has(char *s)
    {
        int len=strlen(s);
        LL ans=0;
        for(int i=0;i<len;i++)
            ans=(ans*10000+s[i])%mod;///注意这里的10000必须足够大,否则可能WA
        return ans;
    }
    char str[105];
    int cnt=0;
    int main()
    {
        while(~scanf("%s",str))
            vis[cnt++]=has(str);
        sort(vis,vis+cnt);
        LL ans=unique(vis,vis+cnt)-vis;
        printf("%lld\n",ans);
        return 0;
    }
    
    展开全文
  • 用普通的快速排序去重,注意保留初始标号,再按照原来的顺序还原结果。 AC代码: var tt,n,i,k:longint; p:array[0..100000] of boolean; a,ans,c:array[0..100000] of longint; procedure swap...
  • if(flag==1) //哈希判定 { int sum=0; int now=1; for(int i=0;i;i++) for(int j=0;j;j++) { sum+=a[i][j]*now; now*=2; } String s=Integer.toBinaryString(sum); ...
  • 如何利用哈希表对放入的串去重: 举个不知道从哪儿看来的例子,把每个hash值当成一只猪,把当前放入的hash%某一个数x相同的猪赶到同一个猪圈, 下次你插入一个数,求得%x的值,按照这个索引去那个猪圈找就好了...
  • 传统的Hash算法只负责将原始内容尽量均匀随机地映射为一个签名值,原理上仅相当于伪随机数产生算法...所以传统的Hash是无法在签名的维度上来衡量原内容的相似度,而SimHash本身属于一种局部敏感哈希算法,它产生的h...
  • 问题描述: 给定两个数组,编写一个函数来计算它们的交集。 示例 1: 输入: nums1 = [1,2,2,1], nums2 = [2,2] 输出: [2] 示例 2: ...输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4] ...使用两个哈希表...
  • 对于去重本人思考了一会,可以考虑使用哈希的方法. import java.util.Scanner; public class ShiYan5_7_5 {  public static void main(String[] args){  System.out.println("请输入十个数:");  Scanner in =...
  • 哈希表数组去重

    2017-05-03 15:56:00
    方式2:建立一个哈希表,通过对象属性查询去除重复元素 function unique (array){ var hash = {}, len = array.length, result = [], i; for(i = 0; i ; i++){ if(!hash[a[i]]){ hash[a[i]] = true;...
  • 解题思路: 使用DFS生成所有可能的排列情况。...每个子集存入result时,将其保存在Set中,下次遇到该子集时即可跳过,以此实现去重。 function dfs(nums, subset, result, set, current) { // 当current等
  • 傻瓜 用于我损坏的存储卡的基于哈希的文件去重
  • 通过哈希算法实现图片去重

    千次阅读 2018-05-02 22:27:25
    采用感知哈希算法基于python-PIL的图像去重 https://blog.csdn.net/Gentle_Guan/article/details/73384767 用Python实现通过哈希算法检测图片重复的教程 http://www.jb51.net/article/63320.htm ...
  • 复杂数组去重
  • <Perl> 哈希/列表去重

    2013-08-10 10:07:00
    (原链接) 对一个二维hash去重。用perl,php现成的函数就没有了 比如一个hash(%hash),如下: my %hash = ( '11' => { 'mark' => '14656,13566-13570' 'id' =>...
  • 题目链接 参考博客 题目大意 先给一个字符串,只含小写字母,然后定义了字母的好坏,求包含坏字母数量不超过k的...先前缀和预处理坏字符的数量,然后枚举每个区间,哈希后存于set中去重,输出set的长度即可。 sb的一...
  • 主要实践一个函数对’...## 只针对不可哈希的数据结构(字典/列表/对象集合)去重 # 1 - 简要的通用方法(为了更好的操作 可以扩展的更加丰富) def dedupe(items,key=None): seen = set() for item in items: # - ...
  • 以样例中的集合1和2为例解释一下: 3 3 99 87 101 4 87 101 5 87 7 99 101 18 5 135 18 99 2 1 2 1 3 样例1:两个集合中元素个数分别为:A = 3个,B = 3个(注意不是4个,需要去重),两个集合相同元素2个,所以 Nc=2N...
  • Java集合框架——HashSet集合的去重原理 & 哈希
  • 哈希冲突 解决哈希冲突的常用方法分析 - 云+社区 - 腾讯云 哈希冲突:由于哈希算法被计算的数据是无限的,而计算后的结果范围有限,因此总会存在不同的数据经过计算后得到的值相同,这就是哈希冲突。 解决哈希冲突...
  • 提供一个未经测试的傻瓜方式:用视频剪辑软件,随便加一秒或者减一秒,我觉得可以达到改变文件哈希值的目的。有兴趣的可以试试,只要要求你重新整个文件上传,就证明改成功了。 想学习相关知识...
  • #include &lt;iostream&gt; #include &lt;iostream&gt; #include &lt;fstream&gt; #include &lt;string&gt; #define INF 0x0003ffff typedef unsigned long long ull;...void ...
  • 虽然可以用快排做出来,但是用哈希去重是一个优秀的选择(代码RE好多次了),所以用哈希存下每种情况,存下个数,并用一个point数组指向下标,差不多了,看代码。 代码 #include &lt;cstdio&...
  • 哈希编码,计算汉明距离,设置阈值剔除
  • Python-PIL 采用感知哈希算法基于python-PIL的图像去重 简单小代码

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,705
精华内容 8,282
关键字:

哈希去重