近期代码题学习

最新推荐文章于 2024-09-23 11:27:55 发布
最新推荐文章于 2024-09-23 11:27:55 发布
阅读量239 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xunboang0059/article/details/97966846
版权

近期学习及准备

算法题

long溢出

做网易笔试题，c(99,100)按照如下办法溢出：-90929067940350457
BigInteger 比long更大的整数

	public static long paizu(int n,int m,long k ) {
		if(n-1 ==0||m==0)
			return 1;
		long t =1;
		long sum = n+m-1;
//		m = Math.min(n-1, m);//C(m+n) n=C(m+n) m  取最小即可
		for(int i=0;i<m;i++) {
			t *= sum-i;
            t /= (i+1);
//			if(t>k)
//				break;
		}
		
		return t;
	}
}

可以优化：C(m+n) n=C(m+n) m 取最小即可 减少循环次数

	public static long paizu(int n,int m,long k ) {
		if(n-1 ==0||m==0)
			return 1;
		long t =1;
		long sum = n+m-1;
		m = Math.min(n-1, m);//C(m+n) n=C(m+n) m  取最小即可
		for(int i=0;i<m;i++) {
			t *= sum-i;
            t /= (i+1);
			if(t>k)
			break;
		}
		
		return t;
	}
}

java四舍五入并保留m位小数

//例子是输出六位小数的百分比，不用输出百分号
int wei =1000000;
double suoqiu = (double)((int)(((double)(k-1)/(double)n)*100*wei+0.5))/wei;
System.out.println(String.format("%.6f", suoqiu));
//如果是正常的小数
int wei =1000000;
double suoqiu = (double)((int)(((double)(k-1)/(double)n)*wei+0.5))/wei;
System.out.println(String.format("%.6f", suoqiu));//6是输出的小数的位数

合并两个有序数组

leetcode

import java.util.Arrays;

public class mergeSorted {
    public static int[] merge(int[] nums1, int m, int[] nums2, int n) {
    	int i=m-1;
    	int j =n-1;
    	int k = m+n-1;
    	while(i>=0&&j>=0) {
    		if(nums1[i]>=nums2[j]) {
    			nums1[k] = nums1[i];
    			i--;
    		}else {
    			nums1[k] = nums2[j];
    			j--;
    		}
    		k--;
    	}
    	while(j>=0) {
    		nums1[k--]=nums2[j--];
    	}
        return nums1;
    }
    public static void main(String[] args) {
    	int[] nums1 = new int[] {1,2,3,0,0,0};
    	int[] nums2= {2,5,6};
    	int[] a = merge(nums1, 3,nums2, 3);
    	//System.out.println(a.toString());//错误：打印的是地址值
    	System.out.println(Arrays.toString(a));
	}
}

值得注意：1.打印出数组的值：    	
//System.out.println(a.toString());//错误：打印的是地址值
    	System.out.println(Arrays.toString(a));
    	2.用的是nums1保留原有合并结果：
    	循环结束后，有可能i和j还大于等于0，若j大于等于0，那么需要继续循环，将nums2中的数字继续拷入nums1。若是i大于等于0，那么就不用管，因为混合数组本身就房子nums1中。
    	如果用nums3的话，循环结束i/j 有大于等于0 的都需要循环

DP动态规划

硬币1：

322.零钱兑换
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

import java.util.Arrays;
public class Coin1 {
    public static int coinChange(int[] coins, int amount) {
    	if(coins.length==0)
    		return -1;
    	int[] dp = new int[amount+1];
    	Arrays.fill(dp,1,dp.length,Integer.MAX_VALUE);
        for(int i=0;i<coins.length;i++) {
        	for(int j=coins[i];j<=amount;j++) {
        		if(dp[j-coins[i]] != Integer.MAX_VALUE) {
    				dp[j] = Math.min(dp[j], dp[j-coins[i]]+1);
    			}
        	}
        }
        if(dp[amount] != Integer.MAX_VALUE)
    		return dp[amount];
    	return -1;
        
    }
	public static void main(String[] args) {
		int[] coins1 = {1, 2, 5};
		int amount1=11;
		System.out.println(coinChange(coins1,amount1));
		int[] coins2 = {2};
		int amount2=3;
		System.out.println(coinChange(coins2,amount2));
	}

}

注意：1.初始化数组，边界dp[0]=0,其他为无穷大
2.for循环方向：越少重复的方向

硬币2：

518.零钱兑换2
给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

public class Coin2 {
    public static int change(int amount, int[] coins) {
    	//输入0,[]：默认输出1
//    	if(coins.length==0)
//    		return 0;
    	int[] dp = new int[amount+1];
    	dp[0]=1;//d[0] 时为初始条件，表示0元可以用0元兑换1次，所以 d[0] = 1。
        for(int i=0;i<coins.length;i++) {
        	for(int j=coins[i];j<=amount;j++) {
        		dp[j] = dp[j]+dp[j-coins[i]];	
        	}
        }
        return dp[amount]; 
    }
	public static void main(String[] args) {
		int[] coins1 = {1, 2, 5};
		int amount1=5;
		System.out.println(change(amount1,coins1));
		int[] coins2 = {2};
		int amount2=3;
		System.out.println(change(amount2,coins2));
		int[] coins3 = {10};
		int amount3= 10;
		System.out.println(change(amount3,coins3));		
	}
}

注意：1.初始化数组，边界dp[0]=1,其他为0
2.for循环方向：越少重复的方向

进制转换

String str4 = Integer.toString(i,x) ;  ///10进制的数字i转换成x进制的字符串
int y4=Integer.valueOf("101",7);        //7进制转换成10进制
System.out.println(y4);
Integer.valueOf("str",x); ///可以为任意进制的字符串str转换成x进制的10进制数
System.out.println("其它的可能用到的函数：");
//static int parseInt(String s, int radix) //使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
int n = Integer.parseInt("776", 8) ; ///8进制转换成10进制
System.out.println(n);
///Integer.valueOf()返回一个“integer对象”和Integer.parseInt()返回一个“int值”的区别在于，返回值不同
///基本常识，其他的非10进制的数的保存，基本都是以字符串的形式
///例子：7进制到8进制的转换
String q = "6523" ; ///7进制的字符串
String b = Integer.toString(Integer.valueOf(q,7),8) ;///这样7进制就变成8进制了

华为+商汤笔试：七进制求和


/*
 * 两种做法：
 * 1.七进制转化为十进制，求和后在转化为七进制
 * 2.两个七进制数逐一相加，有进位进一
 */
import java.util.Arrays;

public class st {
	public static void main(String[] args) {
		
		System.out.println(sumSeven(361,512));
		System.out.println(sumSeven(15,12));
		System.out.println(jinzhi(361,512));
		System.out.println(jinzhi(15,12));
	}
	public static String sumSeven(int m,int n) {
        int[] a = fen(m);
        int[] b= fen(n);
        int i=0;
        int[] sum = new int[10];
        int flag =0;
        while(i<a.length || i<b.length) {
        	
        	sum[i] = a[i]+b[i]+flag;
        	flag =0;
        	if(sum[i]>=7) {
        		sum[i] =sum[i]-7;
        		flag =1;
        	}
        	i++;
        }
        if(flag==1) {
        	sum[i] =1;
        	i++;
        }
        sum = Arrays.copyOfRange(sum, 0, i);// 截断数组
        String a1 ="";
        for(int i1=sum.length-1;i1>=0;i1--) {
        	
        	a1 += sum[i1];
        }
        return a1;
	}
	public static int[] fen(int m) {
		int[] m1 = new int[10];//假设整数有这么多位数字
        int i = 0;
        if (m > 0) { // 正整数
            while (m > 0) {
                m1[i] = m % 10;
                m = m / 10;
                i++;
            }
        }
        int[] n = Arrays.copyOfRange(m1, 0, i);// 截断数组
        return n;
        
	}
	
	/*
	 * 进制转换
	 */
	public static String jinzhi(int m,int n) {
		//str = String.valueOf(int)：int转string
		int a =Integer.valueOf(String.valueOf(m),7);//7进制转10进制
		int b =Integer.valueOf(String.valueOf(n),7);
		int c =a+b;
		String d = Integer.toString(c, 7);//10进制转7进制
		return d;
	}

}

字符串

在这里插入图片描述
面试的时候让手写代码
在这里插入图片描述
以上代码有几个错误：
1.定义的存储数组a 应该是字符串类型，不应该是int类型
2.for循环里面：i<a.length()是错误的，因为for循环里面还有i+1
3.大写字母的ASCII码比小写字母小32，不是+32
4.直接 a[i] =s[i+1]-32;i++;会导致此时的a[i]为空
5.返回值应该是字符串类型，因为自己不会写返回数组类型
总结：还是要快速大量的刷题；字符串掌握不好
自己私下敲了一下代码，用了 两种方法，一种侧重于引入数组，另一种侧重于字符串本身的操作。
引入数组：

public class XiahuaxianDaxie {
	public static String transform(String s) {
		String [] a = new String[s.length()];
		int l=0;
		for(int i=0;i<s.length()-1;i++) {
			
			if(s.charAt(i) =='_') {
				a[i] ="";//char没有'';
				i++;
				a[i] =String.valueOf((char)(s.charAt(i)-32));
				
			}else
			{
				a[i] =String.valueOf(s.charAt(i));
			}
			l=i;
		}
		a[l+1] =String.valueOf(s.charAt(s.length()-1));
		
		StringBuilder str = new StringBuilder();
		for (String s1 : a) {
		    str.append(s1);
		}
		return str.toString(); // 012345
	}
	public static void main(String[] args) {
		System.out.println(transform("my_str_name"));
		System.out.println(transform("my_str_my_list_item"));
		System.out.println(transform("my_str my_list_item"));
		System.out.println(transform("usenr_name_uu_u_"));
		
	}

}

其中，字符串数组转字符串的方法有下面两种：
引入StringBuilder/StringBuffer

		StringBuilder str = new StringBuilder();
		for (String s1 : a) {
		    str.append(s1);
		}
		return str.toString();

直接字符串操作：

		String str1 =" ";
		for (String s1 : a) {
		    str1 += s1;
		}
		return str1;

只有String类型的有"",char没有空’’.
字符串操作:

public class XiahuaxianDaxie2 {
	   //首字母大写
    public static String captureName(String name) {
        name = name.substring(0, 1).toUpperCase() + name.substring(1);
       return  name;
      
    }
//将字符串name 转化为首字母大写。但是这种效率并不高，我之前看过一个牛人的写的方法核心代码，是这样的

    //首字母大写
    public static String captureName1(String name) {
        char[] cs=name.toCharArray();
        cs[0]-=32;
        return String.valueOf(cs);
        
    }
	public static String transform(String s) {
		String newString ="";
		if(s.indexOf("_")!=-1 && s.indexOf("_") !=s.length()-1) {
			while(s.indexOf("_")!=-1 && s.indexOf("_") !=s.length()-1) {
				int first = s.indexOf("_");
				newString = newString + s.substring(0, first);
				s =captureName(s.substring(first+1));
			}
			newString += s;
			return newString;
		}
		else {
			return s;
		}
	}
	public static void main(String[] args) {
		System.out.println(transform("my_str_name"));
		System.out.println(transform("my_str_my_list_item"));
		System.out.println(transform("my_str my_list_item"));
		System.out.println(transform("usenr_name_uu_u_"));
		
	}

}

其中涉及字符串的操作在java基础知识讲解。

单例模式

参考：
代码解释
6种
5种
7种
为什么使用 枚举类

深度优先搜索和广度优先搜索

小灰
孙正豪

求二叉树的深度或者广度

牛客
三种方法
leetcode

二叉树的层序遍历（bfs）

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;


public class levelOrder {
	public static List<List<Integer>> level(TreeNode root) {
		List<List<Integer>> res = new ArrayList<>();
		if(root==null)
			return res;
		Queue<TreeNode> queue = new LinkedList<TreeNode>();
		queue.add(root);
		while(!queue.isEmpty()) {
			int count = queue.size();
			List<Integer> list = new ArrayList<Integer>();
			while(count>0) {
//				System.out.println("count");
//				System.out.println(count);
				TreeNode node = queue.poll();
	            list.add(node.val);
//	            System.out.println(node.val);
	            if(node.left != null)
	                queue.add(node.left);
	            if(node.right != null)
	                queue.add(node.right);
	            count--;
//	            System.out.println(count);
			}
			res.add(list);
		}
	        return res;
	    }
	 public static void main(String[] args) {
		 TreeNode aBiTree = new TreeNode (1);
	        
	        aBiTree.left=new TreeNode(2);
	        aBiTree.right=new TreeNode(3);
	        aBiTree.left.right=new TreeNode(4);
	        System.out.println(level(aBiTree));

}
}
class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode(int x) { val = x; }
 }

LinkedHashMap实现LRU

//整型
import java.util.LinkedHashMap;
import java.util.Map;

public class LRU {
    LinkedHashMap<Integer, Integer> hashMap;

    public LRU(int capacity) {


        hashMap = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry eldest) {

                return size() > capacity;
            }
        };
    }

    public int get(int key) {
        return hashMap.getOrDefault(key, -1);
    }

    public void put(int key, int value) {
        hashMap.put(key, value);
    }
    public void print() {
		for (Map.Entry entry : hashMap.entrySet()) {
			System.out.print(entry.getValue() + "--");
		}
		System.out.println();
	}
    public static void main(String[] args) {
    	LRU cache = new LRU( 2 /* 缓存容量 */ );

    	cache.put(1, 1);
    	cache.put(2, 2);
    	cache.print();
    	System.out.println(cache.get(1));       // 返回  1
    	cache.print();
    	cache.put(3, 3);    // 该操作会使得密钥 2 作废
    	cache.print();
    	System.out.println(cache.get(2)); // 返回 -1 (未找到)
    	cache.put(4, 4);    // 该操作会使得密钥 1 作废
    	cache.get(1);       // 返回 -1 (未找到)
    	cache.get(3);       // 返回  3
    	cache.get(4);       // 返回  4
    }
}


//泛型
import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K,V> {
	LinkedHashMap <K,V> hashmap;
	public LRUCache(int capacity) {
		hashmap = new LinkedHashMap <K,V>(capacity, 0.75f, true) {
			protected boolean removeEldestEntry(Map.Entry<K,V> eldest){
			return size()> capacity;
			}
		};
	}
	public V get(K key) {
		return hashmap.get(key);
	}
	public void put(K key,V value) {
		hashmap.put(key,value);
	}
	public void print() {
		for (Map.Entry<K, V> entry : hashmap.entrySet()) {
			System.out.print(entry.getValue() + "--");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		LRUCache<String, Integer> LRUMap = new LRUCache<>(3);
		LRUMap.put("key1", 1);
		LRUMap.put("key2", 2);
		LRUMap.put("key3", 3);
		LRUMap.print();
		System.out.println();
		LRUMap.put("key4", 4);
		LRUMap.print();
		System.out.println(LRUMap.get("key4"));
		System.out.println(LRUMap.get("key5"));
	}
}

微信拼手气红包

二倍均值法：

结论：剩余红包金额为M，剩余人数为N，那么有如下公式：
每次抢到的金额 = 随机区间 （0， M / N X 2）
这个公式，保证了每次随机金额的平均值是相等的，不会因为抢红包的先后顺序而造成不公平。
举例子：
假设有10个人，红包总额100元。
100/10X2 = 20, 所以第一个人的随机范围是（0，20 )，平均可以抢到10元。
假设第一个人随机到10元，那么剩余金额是100-10 = 90 元。
90/9X2 = 20, 所以第二个人的随机范围同样是（0，20 )，平均可以抢到10元。
…保证每次机会均等。

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
//@param totalAmount 总金额（以分为单位）
//二倍均值法
public class hongbao {
	public static List<Integer> divideRedPackage(Integer totalAmount, Integer totalPeopleNum){
		List<Integer> amountList = new ArrayList<Integer>();
		Integer restAmount = totalAmount;
		Integer restPeopleNum = totalPeopleNum;
		Random random = new Random();
		for(int i=0;i<totalPeopleNum-1;i++) {
			//随机范围：[1,剩余人均金额的2倍-1]分：保证平均值为剩余人均金额
			int amount =random.nextInt(restAmount/restPeopleNum*2-2)+1;
			restAmount -= amount;
			restPeopleNum --;
			amountList.add(amount);
		}
		amountList.add(restAmount);//最后一个人剩余的钱
		return amountList;
	}
	public static void main(String[] args) {
		List<Integer> amountList = divideRedPackage(1000,10);
		//增强for循环 foreach
		for(Integer amount:amountList) {
			System.out.println("抢到金额:"+new BigDecimal(amount).divide(new BigDecimal(100)));
			//System.out.println("抢到金额:"+amount/100);//结果取整 没有小数点
		}
	}

}

线段切分法

二倍均值法缺点：除了最后一次，任何一次的金额都小于人均金额的两倍，并不是任意的均等。
在这里插入图片描述
如何确定每一条子线段的长度呢？由“切割点”来决定。当N个人一起抢红包的时候，就需要确定N-1个切割点。
因此，当N个人一起抢总金额为M的红包时，我们需要做N-1次随机运算，以此确定N-1个切割点。随机的范围区间是（1， M）。
当所有切割点确定以后，子线段的长度也随之确定。这样每个人来抢红包的时候，只需要顺次领取与子线段长度等价的红包金额即可。
这就是线段切割法的思路。在这里需要注意以下两点：
1.当随机切割点出现重复，如何处理。
2.如何尽可能降低时间复杂度和空间复杂度。

import java.math.BigDecimal;
import java.util.*;
//这个方法也更方便抑制红包金额MAX情况，如果金额index-start>MAX,就直接把红包设为最大值MAX，
//然后随机点重置为start+MAX，保证所有红包金额相加等于总金额。
public class hongbaoxianduanqiege {
	public static List<Integer>  divideRedPackage(int allMoney, int peopleCount,int MAX) {
		//人数比钱数多则直接返回错误
        if(peopleCount<1||allMoney<peopleCount){
            System.out.println("钱数人数设置错误！");
            return null;
        }
        List<Integer> indexList = new ArrayList<>();
        List<Integer> amountList = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < peopleCount - 1; i++) {
            int index;
            do{
                index = random.nextInt(allMoney - 2) + 1;
            }while (indexList.contains(index));//解决碰撞
            indexList.add(index);
        }
        Collections.sort(indexList);
        int start = 0;
        for (Integer index:indexList) {
                //解决最大红包值
            if(index-start>MAX){
                amountList.add(MAX);
                start=start+MAX;
            }else{
                amountList.add(index-start);
                start = index;
            }
        }
	
    amountList.add(allMoney-start);
    return amountList;
}
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=Integer.parseInt(in.nextLine());
        int pnum=Integer.parseInt(in.nextLine());
        int money=n*100;int max=n*90;
        List<Integer> amountList = divideRedPackage(money, pnum,max);
        if(amountList!=null){
            for (Integer amount : amountList) {
                System.out.println("抢到金额：" + new BigDecimal(amount).divide(new BigDecimal(100)));
            }
        }}

}

在这里插入图片描述
在这里插入图片描述

五亿大整数，怎么排

外部排序，bitmap

BItmap 大数据的应用

大数据bitmap

买卖股票


dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max(   选择 rest  ,           选择 sell      )
 
解释：今天我没有持有股票，有两种可能：
要么是我昨天就没有持有，然后今天选择 rest，所以我今天还是没有持有；
要么是我昨天持有股票，但是今天我 sell 了，所以我今天没有持有股票了。
 
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max(   选择 rest  ,           选择 buy         )
 
解释：今天我持有着股票，有两种可能：
要么我昨天就持有着股票，然后今天选择 rest，所以我今天还持有着股票；
要么我昨天本没有持有，但今天我选择 buy，所以今天我就持有股票了。

dp[-1][k][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0 。
dp[-1][k][1] = -infinity
解释：还没开始的时候，是不可能持有股票的，用负无穷表示这种不可能。
dp[i][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0 。
dp[i][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的，用负无穷表示这种不可能。

状态转移方程：

base case：
dp[-1][k][0] = dp[i][0][0] = 0
dp[-1][k][1] = dp[i][0][1] = -infinity
 
状态转移方程：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
hello,world_yzs
关注
专栏目录
java 找硬币_动态规划法求解硬币找零(Java)
weixin_36026440的博客
02-24 264
算法描述：动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。基本思想也是将待求解问题分解成若干个子问题，先求解子问题，并将子问题的结果保存下来，然后从这些子问题的解得到原问题的解。动态规划实质上是一种以空间换时间的技术，它在实现的过程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其它的算法。问题描述：...
算法思维方式之二——DP与DFS
weixin_30657999的博客
08-19 370
这类问题一般是给出候选集合（一般为数组 array [ ]）和一个限定值(S)，然后让你求某一结果。 一般DFS与DP均可。下面谈谈这两种思维方式不同。 DFS一般是对数组array元素进行讨论，比如最后一个元素的有无。然后顺序递归，削减数组长度，通过递归遍历整个数组，得出最终结果。 比如全排列问题，比如组合问题。 DP则直接对限定值S进行讨论，比如S-array[n] 的值是什么。通过讨...
Java中Integer的valueOf()方法
qq_42575499的博客
03-24 1万+
valueOf()包含包含3个相互重载的具体方法。 一、valueOf(String s, int radix) 该方法将字符串s中隐含的数字按照radix指定的进制解析为10进制整数，如果字符串s中隐含非数字字符，则抛出 NumberFormatException 异常 例子 Integer.valueOf("1a", 16); 上面例子的结果应该是16+10=27（a表示16进制中的10），v...
算法-动态规划算法（详解）
热门推荐
donkeyboy001的博客
10-10 2万+
动态规划算法介绍 1）动态规划（Dynamic Programming）算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法 2）动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 3）与分治法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是互相独立的。（即下一个子阶段的求解是建立在上一个子阶段的解的基础上， 进行进一步的求解） 4）动态规划可以通过填表的方式来逐步推进，得到最优解。
java零钱换整程序_Java动态规划之硬币找零问题实现代码
weixin_32401763的博客
01-15 345
动态规划的基本思想是将待求解问题分解成若干个子问题，先求解子问题，并将这些子问题的解保存起来，如果以后在求解较大子问题的时候需要用到这些子问题的解，就可以直接取出这些已经计算过的解而免去重复运算。保存子问题的解可以使用填表方式，例如保存在数组中。用一个实际例子来体现动态规划的算法思想——硬币找零问题。问题描述:假设有几种硬币，并且数量无限。请找出能够组成某个数目的找零所使用最少的硬币数。例如几种硬...
机器学习西瓜书习题代码部分实现
01-07
机器学习西瓜书习题代码部分实现
蓝桥杯嵌入式学习资料及往年真题代码
04-12
分别为嵌入式学习准备工作、液晶程序参考例程使用、LED、KEY、USART、液晶驱动程序调用、ADC、RTC、PWM模式、输出比较PWM、输入捕获、蜂鸣器。 同时也提供官网的范例程序供参考。 以及历届模拟赛题资料、嵌入式...
在线试题库系统代码 java在线试题库系统代码
03-09
在线试题库系统代码 java在线试题库系统代码 基于springboot的在线试题库系统代码 1、在线试题库系统的技术栈、环境、工具、软件： ① 系统环境:Windows/Mac ② 开发语言：Java ③ 框架：SpringBoot ④ 架构:B/S、...
Siemens Mendix低代码平台学习资料和认证试题
07-19
Siemens Mendix低代码平台相关学习资料。 Mendix是美国一个代码应用开发平台，现已经被Siemens工业软件收购，主要提供IBM、SAP和Pivotal的云服务，开发人员、业务分析人员可通过使用可视化模型，在平台上构建应用...
C++ 孔令德计算机图形学习题答案源代码
03-17
《C++ 孔令德计算机图形学习题答案源代码》是一个专门为学习计算机图形学的学生或爱好者准备的资源，其中包含了孔令德教授课程中的习题解答。这些源代码是使用C++编程语言编写的，因此对于熟悉C++的读者来说，它们...
算法题整理1——三月打卡题目
lzm123456的博客
03-13 411
1.1103. 分糖果 II 思想：循环人数，依次分得糖果数目，糖果数目是当前剩下的糖果数和应分得的糖果数取最小值 package Day; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * @author lzm * @create 2020- 03- 05- 13:23 ...
PAT 1048 Find Coins 散列/双指针
Yerkeys的博客
03-17 101
Eva loves to collect coins from all over the universe, including some other planets like Mars. One day she visited a universal shopping mall which could accept all kinds of coins as payments. However,...
二维动态规划降维误差一般为多少_动态规划-背包问题降维
weixin_39665847的博客
12-18 107
0-1 背包问题：0-1 背包问题解决的是物品只能够选择1次要不就不选，在背包能够装得下的前提下面，能够保证装的价值最大：状态转移方程 f[i][j] = max{ f[i-1][j] , f[i-1][j - wi] +vi }; 0≤j - wi≤j用二维的空间来表示是比较简单的一维表示：f[v] 表示 f[i][v] , 那么由于上面的这个公式： f[i][j] = max{ f[i-1][...
Java 零钱兑换
clinke的博客
08-21 1295
Java 零钱兑换 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。 示例 1: 输入: coins = [1, 2, 5], amount = 11 输出: 3 解释: 11 = 5 + 5 + 1 示例 2: 输入: coins = [2], amount = 3 输出: -1...
钱币组合问题（一）：（每种硬币不限次数）
小雄鹿的博客
09-25 9694
钱币组合问题（一）：（每种硬币不限次数） 假设我们有8种不同面值的硬币｛1，2，5，10，20，50，100，200｝，用这些硬币组合够成一个给定的数值n。例如n=200，那么一种可能的组合方式为 200 = 3 * 1 + 1＊2 + 1＊5 + 2＊20 + 1 * 50 + 1 * 100. 问总过有多少种可能的组合方式？ 思路一：暴力穷举 每种硬币最多为N/coin
找硬币和背包问题
weixin_34021089的博客
10-03 137
2019独角兽企业重金招聘Python工程师标准>>> ...
Leetcode 三动态规划 硬币
10-31 176
算法： 代码实现： public static int coinChange(int[] coins, int amount) { int dp[] = new int[amount+1]; Arrays.fill(dp,amount+1); dp[0]=0; for(int i=1;i<=amount;i++){ for(int j=0;j<coins.length;j++){ if(coins[j]<=.
动态规划学习笔记以及例题硬币交换、数组左上到右下最多路径、青蛙跳问题、做工最挣钱、选数字等
pinganguo11的博客
10-23 212
动态规划 题目特点： **基本思想：**将待求解的问题分解成若干个子问题，先求解子问题，然后从这若干个子问题（和分治区别：往往不独立）的解中得到原问题的解。有些子问题或许被重复计算多次，在动态规划中，会保存每个被计算过子问题的解，将其填入表中。 动态规划一般步骤 找出最优解的性质，刻画其结构特征 递归定义最优值 自底向上计算最优值 根据最优质时得到的信息，构造最优解 1-3是基本步骤，第四步可以视情况省去 例题 Coin Change问题 这是一个求最大最小值的问题(75555) 贪心，尽量大——77
力扣 困难 154.寻找旋转排序数组中的最小值 II
最新发布
qq_51352130的博客
09-23 181
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
langchain 代码学习
03-29
Langchain是一个开源的代码学习平台，它旨在帮助开发者通过实际的代码示例来学习编程语言和技术。Langchain提供了大量的代码示例和练习题，涵盖了多种编程语言和技术领域，包括但不限于Java、Python、C++、Web开发等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值