F.小红的数组分组

已于 2024-02-25 21:43:14 修改
阅读量493 收藏 8
点赞数 13
文章标签： 算法
于 2024-02-25 16:39:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xing_ke/article/details/136283708
版权
文章描述了一种优化算法，用于解决关于集合中元素具有相同质因子的问题，通过预处理质数和最小质因子，避免重复访问和超时，以高效地找出满足条件的元素组合。
摘要由CSDN通过智能技术生成

 解题思路

  • 维护集合，满足集合内一个元素一定存在另一个元素与其有某一个相同的质因子(size>1)
  • 若集合只有一个，则无解
  • 特判存在1，则1单独放一个，其余放一起
  • 预处理出1e6内所有质数的同时，可以处理出每个数的最小质因子
  • 对于任意一个数，while(x/=mifac[x])可以得到该数所有质因子
  • 避免了对于1e6内某一数进行质因数分解时
  • while从2开始++查找 或 利用已经求出的质数for从小到大进行尝试
  • 注意维护集合时，不要通过质因子将其能整除的一块处理，因为会有已经被处理过的，虽然不计，但会访问，重复访问会超时
  • 而自己处理自己的，相互之间通过质因子进行联系，这样每个至多访问一次
  • 注意java不要在循环中建数组，会超时。直接建全局，结束时进行删除即可。

最优解 


import java.io.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;







public class Main{
	static long md=(long)998244353;
	static long Linf=Long.MAX_VALUE/2;
	static int inf=Integer.MAX_VALUE/2;
	
	
	static int find(int x,int[] fa) {
		if(x==fa[x])return x;
		else return fa[x]=find(fa[x], fa);
	}
	 
	
	public static void main(String[] args) throws IOException{
		AReader input=new AReader();
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    int N=1000000;
	    int[] prim=new int[1000001];
	    int cnt=0;
	    boolean[] isnotprim=new boolean[1000001];
	    int[] facmi=new int[1000001];
	    for(int i=2;i<=N;++i) {
	    	if(!isnotprim[i]) {
	    		cnt++;
	    		prim[cnt]=i;
	    		facmi[i]=i;
	    	}
	    	for(int j=1;j<=cnt;++j) {
	    		int now=prim[j]*i;
	    		if(now>N)break;
	    		isnotprim[now]=true;
	    		facmi[now]=prim[j];
	    		if(i%prim[j]==0)break;
	    	}
	    }
	    int[] a=new int[200001];
	    int[] b=new int[200001];
	    int[] c=new int[200001];
	    int[] fa=new int[1000001];
	    HashSet<Integer> ol=new HashSet<Integer>();
	    int q=input.nextInt();
	    while(q>0) {
	    	
	    	int n=input.nextInt();
	    	
	    	int one=0;
	    	int mx=0;
	    	for(int i=1;i<=n;++i) {
	    		a[i]=input.nextInt();
	    		fa[a[i]]=a[i];
	    		ol.add(a[i]);
	    		mx=Math.max(mx, a[i]);
	    	}
	    	if(one!=0) {
	    		out.println(one+" "+(n-one));
	    		for(int i=1;i<=one;++i) {
	    			out.print(1+" ");
	    		}
	    		out.println();
	    		for(int i=1;i<=n;++i) {
	    			if(a[i]!=1)out.print(a[i]+" ");
	    		}
	    		out.println();
	    		q--;
	    		for(int x:ol) {
	    			fa[x]=0;
	    		}
	    		ol.clear();
	    		continue;
	    	}
	    	for(int i=1;i<=cnt;++i) {
	    		if(prim[i]>mx)break;
	    		fa[prim[i]]=prim[i];
	    		ol.add(prim[i]);
	    	}
//	    	boolean[] vis=new boolean[mx+1];//其实还可以去个重
	    	for(int i=1;i<=n;++i) {
//	    		if(vis[a[i]])continue;
//	    		vis[a[i]]=true;
	    		int x=a[i];
	    		int fx=find(x, fa);
	    		while(x!=1) {
	    			int y=facmi[x];
	    			int fy=find(y, fa);
	    			if(fy!=fx)fa[fy]=fx;
	    			x/=y;
	    		}
	    	}
	    	
	    	
	    	int bb=0;
	    	int cc=0;
	    	int bf=find(a[1], fa);
	    	for(int i=1;i<=n;++i) {
	    		int fx=find(a[i], fa);
	    		if(fx==bf) {
	    			bb++;
	    			b[bb]=a[i];
	    		}else {
	    			cc++;
	    			c[cc]=a[i];
	    		}
	    	}
	    	if(bb==n) {
	    		out.println("-1 -1");
	    		q--;
	    		for(int x:ol) {
	    			fa[x]=0;
	    		}
	    		ol.clear();
	    		continue;
	    	}
	    	out.println(bb+" "+cc);
	    	for(int i=1;i<=bb;++i) {
	    		out.print(b[i]+" ");
	    	}
	    	out.println();
	    	for(int i=1;i<=cc;++i) {
	    		out.print(c[i]+" ");
	    	}
	    	out.println();
	    	q--;
	    	for(int x:ol) {
    			fa[x]=0;
    		}
    		ol.clear();
	    }
	    
 	    out.flush();
	    out.close();
	}
	//System.out.println();
	//out.println();
	static
	class AReader{ 
	    BufferedReader bf;
	    StringTokenizer st;
	    BufferedWriter bw;

	    public AReader(){
	        bf=new BufferedReader(new InputStreamReader(System.in));
	        st=new StringTokenizer("");
	        bw=new BufferedWriter(new OutputStreamWriter(System.out));
	    }
	    public String nextLine() throws IOException{
	        return bf.readLine();
	    }
	    public String next() throws IOException{
	        while(!st.hasMoreTokens()){
	            st=new StringTokenizer(bf.readLine());
	        }
	        return st.nextToken();
	    }
	    public char nextChar() throws IOException{
	        //确定下一个token只有一个字符的时候再用
	        return next().charAt(0);
	    }
	    public int nextInt() throws IOException{
	        return Integer.parseInt(next());
	    }
	    public long nextLong() throws IOException{
	        return Long.parseLong(next());
	    }
	    public double nextDouble() throws IOException{
	        return Double.parseDouble(next());
	    }
	    public float nextFloat() throws IOException{
	        return Float.parseFloat(next());
	    }
	    public byte nextByte() throws IOException{
	        return Byte.parseByte(next());
	    }
	    public short nextShort() throws IOException{
	        return Short.parseShort(next());
	    }
	    public BigInteger nextBigInteger() throws IOException{
	        return new BigInteger(next());
	    }
	    public void println() throws IOException {
	        bw.newLine();
	    }
	    public void println(int[] arr) throws IOException{
	        for (int value : arr) {
	            bw.write(value + " ");
	        }
	        println();
	    }
	    public void println(int l, int r, int[] arr) throws IOException{
	        for (int i = l; i <= r; i ++) {
	            bw.write(arr[i] + " ");
	        }
	        println();
	    }
	    public void println(int a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(int a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(String a) throws IOException{
	        bw.write(a);
	        bw.newLine();
	    }
	    public void print(String a) throws IOException{
	        bw.write(a);
	    }
	    public void println(long a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(long a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(double a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(double a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void print(char a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(char a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	}
}

 超时解

  • 会超最后一个点，也是赛时代码
import java.io.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;







public class Main{
	static long md=(long)998244353;
	static long Linf=Long.MAX_VALUE/2;
	static int inf=Integer.MAX_VALUE/2;
	
	
	static int find(int x,int[] fa) {
		if(x==fa[x])return x;
		else return fa[x]=find(fa[x], fa);
	}
	 
	
	public static void main(String[] args) throws IOException{
		AReader input=new AReader();
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	  
	    HashMap<Integer, HashSet<Integer>> NumhsPrim=new HashMap<Integer, HashSet<Integer>>();//每个数的质因子
	   
	    HashSet<Integer> now=new HashSet<Integer>();
	    
	    
	    int q=input.nextInt();
	    while(q>0) {
	    	int n=input.nextInt();
	    	int[] a=new int[n+3];
	    	for(int i=1;i<=n;++i)a[i]=input.nextInt();
	    	Arrays.sort(a,1,n+1);
	    	HashMap<Integer, Integer> d=new HashMap<Integer, Integer>();//统计相同个数
	    	int o=0;
	    	for(int i=1;i<=n+1;++i) {
	    		if(a[i]==a[i-1]) {
	    			o++;
	    		}else {
	    			d.put(a[i-1], o);
	    			o=1;
	    		}
	    	}
	    	int[] e=new int[n+1];o=0;//去重
	    	for(int i=1;i<=n;++i) {
	    		if(a[i]==a[i-1])continue;
	    		o++;
	    		e[o]=a[i];
	    	}
	    	
	    	int[] b=new int[n+1];
	    	int bc=0;
	    	int[] c=new int[n+1];
	        int cc=0;
	    	if(e[1]==1) {//1自己为一组，其它放一组
                bc=d.get(1);
                
	    		
	    		for(int i=2;i<=o;++i) {
	    			int p=d.get(e[i]);
	    			for(int j=1;j<=p;++j) {
	    				cc++;
	    				c[cc]=e[i];
	    			}
	    		}
	    		out.println(bc+" "+cc);
	    		for(int i=1;i<=bc;++i) {
	    			out.print(1+" ");
	    		}
	    		out.println();
	    		for(int i=1;i<=cc;++i) {
	    			out.print(c[i]+" ");
	    		}
	    		out.println();
	    	}else {
	    		
	    		for(int i=1;i<=o;++i) {
	    			if(NumhsPrim.get(e[i])==null) {
	    				now=new HashSet<Integer>();
	    				int x=e[i];
	    				int t=2;
	    				while(t<=x) {
	    					if(t==x) {
	    						now.add(t);
	    						break;
	    					}else if(x%t==0) {
	    						now.add(t);
	    						while(x%t==0) {
	    							x/=t;
	    						}
	    					}else t++;
	    				}
	    				NumhsPrim.put(e[i], now);
	    			}
	    		}
	    		
	    		Queue<Integer> qu=new LinkedList<Integer>();
	    		HashSet<Integer> checkover=new HashSet<Integer>();//被处理过的质数不在重复处理
	    		
	    		//该质数是哪些数的因子
	    		HashMap<Integer, Vector<Integer>> PrimhsNum=new HashMap<Integer, Vector<Integer>>();
	    		Vector<Integer> may=new Vector<Integer>();
	    		HashSet<Integer> op=new HashSet<Integer>();
	    		for(int i=1;i<=o;++i) {
	    			op=NumhsPrim.get(e[i]);
	    			for(int x:op) {//该数的所有质因子
	    				if(PrimhsNum.get(x)==null) {
	    					may=new Vector<Integer>();
	    					may.add(i);
	    					PrimhsNum.put(x, may);
	    				}else {
	    					may=PrimhsNum.get(x);
	    					may.add(i);
	    					PrimhsNum.put(x, may);
	    				}
	    			}
	    		}
	    		int[] fa=new int[n+1];
	    		for(int i=1;i<=o;++i)fa[i]=i;
	    		//集合内某一元素一定存在另一个元素与其有相同因子
	    		for(int i=1;i<=o;++i) {
	    			if(fa[i]!=i)continue;
	    			qu=new LinkedList<Integer>();
	    			checkover=new HashSet<Integer>();
	    			op=NumhsPrim.get(e[i]);
	    			for(int x:op) {
	    				qu.add(x);
	    			}
	    			int fx=i;
	    			while(!qu.isEmpty()) {
	    				int x=qu.peek();
	    				qu.poll();
	    				if(checkover.contains(x))continue;
	    				checkover.add(x);
	    				may=PrimhsNum.get(x);
	    				for(int y:may) {//会有重复访问，超时！！！！！
	    					int fy=find(y, fa);
	    					if(fy==fx)continue;//已经处理过了
	    					fa[fy]=fx;
	    					op=NumhsPrim.get(e[y]);
	    					for(int z:op) {//将新的质因子加入
	    						if(!checkover.contains(z)) {
	    							qu.add(z);
	    						}
	    					}
	    				}
	    			}
	    		}
	    		int m=0;
	    		for(int i=1;i<=o;++i) {//有多少个连通块
	    			if(fa[i]==i)m++;
	    		}
	    		if(m==1) {//只有一个连通块，分不开
	    			out.println("-1 -1");
	    		}else {
	    			op=new HashSet<Integer>();
	    			now=new HashSet<Integer>();
	    			int p=0;
	    			for(int i=1;i<=o;++i) {
	    				if(fa[i]==i) {//块头决定放在b/c
	    					if(p==0) {
	    						op.add(i);
	    						int l=d.get(e[i]);
	    						for(int j=1;j<=l;++j) {
	    							bc++;
	    							b[bc]=e[i];
	    						}
                                p=1;
	    					}else {
	    						now.add(i);
	    						int l=d.get(e[i]);
	    						for(int j=1;j<=l;++j) {
	    							cc++;
	    							c[cc]=e[i];
	    						}
                                p=0;
	    					}
	    				}else {
	    					if(op.contains(fa[i])) {//跟着放进去
	    						int l=d.get(e[i]);
	    						for(int j=1;j<=l;++j) {
	    							bc++;
	    							b[bc]=e[i];
	    						}
	    					}else {
	    						int l=d.get(e[i]);
	    						for(int j=1;j<=l;++j) {
	    							cc++;
	    							c[cc]=e[i];
	    						}
	    					}
	    				}
	    			}
	    			out.println(bc+" "+cc);
	    			for(int i=1;i<=bc;++i) {//输出
	    				out.print(b[i]+" ");
	    			}
	    			out.println();
	    			for(int i=1;i<=cc;++i) {
	    				out.print(c[i]+" ");
	    			}
	    			out.println();
	    		}
	    	}
	    	
	    	
	    	
	    	q--;
	    }
 	    out.flush();
	    out.close();
	}
	//System.out.println();
	//out.println();
	static
	class AReader{ 
	    BufferedReader bf;
	    StringTokenizer st;
	    BufferedWriter bw;

	    public AReader(){
	        bf=new BufferedReader(new InputStreamReader(System.in));
	        st=new StringTokenizer("");
	        bw=new BufferedWriter(new OutputStreamWriter(System.out));
	    }
	    public String nextLine() throws IOException{
	        return bf.readLine();
	    }
	    public String next() throws IOException{
	        while(!st.hasMoreTokens()){
	            st=new StringTokenizer(bf.readLine());
	        }
	        return st.nextToken();
	    }
	    public char nextChar() throws IOException{
	        //确定下一个token只有一个字符的时候再用
	        return next().charAt(0);
	    }
	    public int nextInt() throws IOException{
	        return Integer.parseInt(next());
	    }
	    public long nextLong() throws IOException{
	        return Long.parseLong(next());
	    }
	    public double nextDouble() throws IOException{
	        return Double.parseDouble(next());
	    }
	    public float nextFloat() throws IOException{
	        return Float.parseFloat(next());
	    }
	    public byte nextByte() throws IOException{
	        return Byte.parseByte(next());
	    }
	    public short nextShort() throws IOException{
	        return Short.parseShort(next());
	    }
	    public BigInteger nextBigInteger() throws IOException{
	        return new BigInteger(next());
	    }
	    public void println() throws IOException {
	        bw.newLine();
	    }
	    public void println(int[] arr) throws IOException{
	        for (int value : arr) {
	            bw.write(value + " ");
	        }
	        println();
	    }
	    public void println(int l, int r, int[] arr) throws IOException{
	        for (int i = l; i <= r; i ++) {
	            bw.write(arr[i] + " ");
	        }
	        println();
	    }
	    public void println(int a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(int a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(String a) throws IOException{
	        bw.write(a);
	        bw.newLine();
	    }
	    public void print(String a) throws IOException{
	        bw.write(a);
	    }
	    public void println(long a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(long a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(double a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(double a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void print(char a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(char a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	}
}
//想要处理出1e6内所有数分解后的质因数
//对于每次询问的a，进行质因数分解

Xing_ke309
关注
Python常用组件、命令大总结(持续更新)
LDC，公众号【轻松学编程】
03-12 1万+
Python后端开发常用组件、命令（干货） 持续更新中… 1、生成6位数字随机验证码 import random import string def num_code(length=6): """ 生成长度为length的数字随机验证码 :param length: 验证码长度 :return: 验证码 """ return ''.jo.....................
牛客竞赛网周赛（小红的元素分裂）
s44Sc21的博客
11-18 980
题目描述 小红拿到了一个数组，她每次可以进行如下操作之一： ·选择一个元素x，将其分裂为1和x−1。 ·选择一个元素x，将其分裂为a和b，需要保证a∗b=x 小红希望用最少的操作次数，将所有数组的所有元素全部变成1。你能帮帮她吗？ 输入描述: 第一行输入一个正整数n，代表数组的长度。 第二行输入nnn个正整数ai​，代表小红拿到的数组。 1≤n,ai​≤10^5 输出描述: 一个整数，代表最小的操作次数。 示例1 输入 2 2 6 输出 5 说明 第一次，对第一个元素进行第一个操作，数组变成[1,1,
Array---数组的交集、并集、差集、分组、平均数、扁平化、求和、位置交换、归档
COCOLI_BK的博客
08-29 830
1. 数组并集(ArrayUnion)2. 数组交集()3. 数组差集()4. 数组分组(ArrayGroup)5. 数组平均数(ArrayMean)6.数组生成(ArrayRange)7.数组求和(ArraySum)8.数组扁平化()9. 数组值位置交换()10.数组归档(归类)()11. Array.includes判断多个if条件12. Array.find 查找符合条件的数组元素13.数组中所有项都满足某条件：Array.every。...
求一个集合或者数组的所有子集的，最大值，最小值，集合元素个数，极差等问题。
siper12138的博客
09-29 931
集合问题题目描述（1）求集合{1,4,2000}的体积，以及其所有子集的最大值，最小值，元素个数，面积。（2）求数组a[3]={1,4,2000}的体积，以及其所有子数组的最大值，最小值，区间长度，面积。 题目描述 我们 定义一个集合的最大值与最小值的差为这个集合的极差。 定义集合的极差与集合元素个数的乘积为本集合的面积。 定义一个集合所有真子集的面积之和为该集合的体积。 我们 定义一个数组的最大值与最小值的差为这个数组的极差。 若数组元素大于等于2，定义数组的极差与数组长度的乘积为本数组的面积。 若数组元
JS数组reduce的25个高级用法
lnmgmgggggdd的博客
09-27 1623
reduce作为ES5新增的常规数组方法之一,对比forEach 、filter和map,在实际使用上好像有些被忽略，下面这篇文章主要给大家介绍了关于JS数组reduce你不得不知道的25个高级用法，需要的朋友可以参考下 前言 reduce作为ES5新增的常规数组方法之一，对比forEach、filter和map，在实际使用上好像有些被忽略，发现身边的人极少使用它，导致这个如此强大的方法被逐渐埋没。 如果经常使用reduce，怎么可能放过如此好用的它呢！我还是得把他从尘土中取出来擦干净，奉上它.
java reduce.mdn_编程语言你不得不知道的数组reduce高级用法
weixin_31464715的博客
02-27 484
背景距离上一篇技术文章《1.5万字概括ES6全部特性》发布到现在，已经有整整4个月没有输出过一篇技术文章了。哈哈，不是不想写，而是实在太忙，这段时间每天不是上班就是加班，完全没有自己的时间。这篇文章也是抽空之余完成，希望大家喜欢，谢谢大家继续支持我。本文首发于『搜狐技术产品』公众号，首发内容与博客内容略有不同，博客内容今早发布时额外有所增加reduce作为ES5新增的常规数组方法之一，对比forE...
复杂数组遍历组合
czx3387170的博客
11-03 315
二维数组拼接方法，数组合并
分组背包变体
AGNING的博客
07-29 454
分组背包问题的3种形式：每组最多选1个（模板），必须选1个，至少选1个。
es6中reduce的用法_25个你不得不知道的数组reduce高级用法
weixin_29521135的博客
12-31 487
背景距离上一篇技术文章《1.5万字概括ES6全部特性》发布到现在，已经有整整4个月没有输出过一篇技术文章了。哈哈，不是不想写，而是实在太忙，这段时间每天不是上班就是加班，完全没有自己的时间。这篇文章也是抽空之余完成，希望大家喜欢，谢谢大家继续支持我。本文首发于『搜狐技术产品』公众号，首发内容与博客内容略有不同，博客内容今早发布时额外有所增加reduce作为ES5新增的常规数组方法之一，对比forE...
25个你不得不知道的数组reduce高级用法
JowayYoung谈前端
02-13 1256
作者：JowayYoung 仓库：Github 博客：掘金、思否、知乎、简书、头条、CSDN 公众号：IQ前端 联系我：关注公众号后有我的微信哟 特别声明：未经授权不得对此文章进行转载或抄袭，否则通过法律途径进行解决，如需转载或开通公众号白名单可联系我，希望各位尊重原创的知识产权 背景 距离上一篇技术文章《1.5万字概括ES6全部特性》发布到现在，已经有整整4个月没有输出过一篇技术文章了。哈...
Python 与数据科学实验（Exp5）
qq_51314244的博客
04-11 700
(1)。利用随机产生一个的二维数组，其元。完成以下该数组的索引任务，打印输出相关结果：(a) 使用索引方式获取第2行第5列、第6行第3列的元素。(b) 使用切片方式获取第3行至第5行和第4列至第6列的数据。(c) 使用切片与整数序列索引混合的方式，获取第3行至第5行且为第1列、第2列和第4列的数据。(d) 使用布尔索引方法将数组中取值大于1的元素重新赋值为10.00，小于-1的元素重新赋值为-10.00，并打印输出这个新数组。(2)利用numpy中相关模块。
4.Hive的Serde,Server2,函数
农码一生
10-19 515
Hive Serde Hive Serde用来做序列化和反序列化，构建在数据存储和执行引擎之间，对两者实现解耦。 应用场景: hive主要用来存储结构化数据，如果结构化数据存储的格式嵌套比较复杂的时候，可以使用serde的方式，利用正则表达式匹配的方法来读取数据，例如，表字段如下：id,name,map<string,array<map<string,string>>> 当读取数据的时候，数据的某些特殊格式不希望显示在数据中，如：192.168..
python ：pandas数据处理
weixin_42424451的博客
07-11 552
pandas数据处理 1、删除重复元素 使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True 使用drop_duplicates()函数删除重复的行 使用duplicated()函数查看重复的行 import numpy as np import pandas as pd from pandas im...
100天精通Python（数据分析篇）——第53天：初始pandas模块基础
热门推荐
努力让自己发光，对的人才能迎着光而来
08-29 1万+
一、初始pandas 1. 什么是pandas？ 2. 为什么要学习pandas？ 3. pandas的优势 4. 下载安装pandas 二、Pandas的数据类型 1. Series 2. DataFrame
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 261
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 190
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
最新发布
AnFany
11-06 146
100种算法【Python版】第51篇——希尔排序
深⼊理解指针2
ElePower9527的博客
11-01 673
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 291
华为od算法——HJ33
小红书薯条攻略：打造爆文曝光秘籍
"《2022小红书薯条知识分享方案》是一份全面介绍小红书平台薯条功能的指南，旨在帮助用户有效地利用薯条提升笔记曝光度和内容影响力。薯条是小红书推出的一种笔记推广工具，它允许创作者有针对性地增加笔记在平台上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值