快排+归并+背包

快排

int Partion(int A[],int low,int high){
	int pivot = A[low];
	while(low < high){
		while(low < high && A[high] >= pivot)--high;
		A[low] = A[high];
		while(low < high && A[low] <= pivot)++low;
		A[high] = A[low];
		}
		A[low] = pivot;
		return low;
	}

void QuickSort(int A[],int low,int high){
	if(low < high){
		int pos = Partion(A,low,high);
		QuickSort(A,low,pos-1);
		QuickSort(A,pos+1,high);
	}
}

归并

void Merge(int A[],int low,int mid,int high){
	for(i = low;i <= high;i++)B[i] = A[i];
	for(i = low,j = mid+1,k=i;i <= mid && j <= high;k++){
		if(B[i] <= B[j])A[k] = B[i++];
		else A[k] = B[j++];
	}
	while(i <= mid)A[k++] = B[i++];
	while(j <= high)A[k++] = B[j++];
}

void MergeSort(int A[],int low,int high){
	if(low < high){
		int mid = (low+high) / 2;
		MergeSort(A,low,mid);
		MergeSort(A,mid+1,high);
		Merge(A,low,mid,high);
	}
}

北大点菜

int main(){
    int c,n;
    cin >> c >> n;
    int v[n+1],p[n+1];
    for(int i = 1;i <= n;i++)cin >> p[i] >> v[i];
    int dp[n+1][c+1];
    for(int i = 0;i <= n;i++){
        dp[i][0] = 0;
    }
    for(int i = 0;i <= c;i++)dp[0][i] = 0;
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= c;j++){
            if(j < p[i])dp[i][j] = dp[i-1][j];
            else dp[i][j] = max(dp[i-1][j],dp[i-1][j-p[i]]+v[i]);
        }
    }
//    for(int i = 0;i <= n;i++){
//    	for(int j = 0;j <= c;j++){
//    		cout << dp[i][j] << " ";
//		}
//		cout << endl;
//	}
	cout << dp[n][c] <<  endl;
    return 0;
}
// 40 2
// 25 30
// 10 8

八皇后

int main(){
	int b;
	while(cin >> b){
		dfs(0,b);
	}	
}

void dfs(int n,int b){
	if(n > 7){
		total++;
		if(total == b)print();
		return;
	}
	for(int i = 0;i < 8;i++){
		if(check(n,i)){
			arr[n][i] = 1;
			dfs(n+1,b);
			arr[n][i] = 0;
		}
	}
}

bool check(int m,int n){
	for(int i = 0;i < m;i++){
		if(arr[i][n] == 1)return false;
	}
	for(int i = m-1,j = n-1;i >=0 && j >= 0;i--,j--){
		if(arr[i][j] == 1)return false;
	}
//	for(int i = m+1,j = n+1;i < 8,j < 8;i++,j++){
//		if(arr[i][j] == 1)return false;
//	}
	for(int i = m-1,j = n+1;i >= 0,j < 8;i--,j++){
		if(arr[i][j] == 1)return false;
	}
//	for(int i = m+1,j = n-1;i < 8,j >= 0;i++,j--){
//		if(arr[i][j] == 1)return false;
//	}
	return true;
}

void print(){
	for(int i = 0;i < 8;i++){
		for(int j = 0;j < 8;j++){
			if(arr[i][j] == 1)cout << j+1;
		}
	}
	cout <<  endl;
}
Java 常见常用算法详解 Java 作为一门工业级编程语言,其强大的标准库和生态系统内置了大量高效、稳定的算法。同时,理解并能够实现经典算法是程序员的核心能力。本文将从 “直接用” 和 “自己写” 两个维度,系统梳理 Java 开发中的常见算法。 第一部分:开箱即用 — JDK 内置算法 Java 标准库 (java.util 和 java.util.Arrays) 提供了许多现成的算法,它们经过高度优化和严格测试,是日常开发的首选。 1. 排序算法 (Sorting) 核心类: java.util.Collections, java.util.Arrays Collections.sort(List<T> list) 用途: 对 List 集合(如 ArrayList, LinkedList) 进行升序排序。 底层实现: 对于对象集合,它使用一种优化的、稳定的归并排序变体 (TimSort)。稳定性意味着相等元素的相对顺序在排序后保持不变。 时间复杂度: 保证 O(n log n)。 Arrays.sort(int[] a) 用途: 对基本类型数组(如 int[], double[]) 进行排序。 底层实现: 使用双轴快速排序 (Dual-Pivot Quicksort)。该算法是对经典快排的改进,在实践中效率极高。 Arrays.sort(T[] a) 用途: 对对象数组(如 String[], Integer[]) 进行排序。 底层实现: 同样使用 TimSort 算法,保证稳定性和高性能。 示例代码: java import java.util.*; // 1. 对List排序 List<Integer> numbersList = new ArrayList<>(Arrays.asList(23, 5, 42, -1, 99)); Collections.sort(numbersList); System.out.println("Sorted List: " + numbersList); // 输出: Sorted List: [-1, 5, 23, 42, 99] // 2. 对数组排序 int[] numbersArray = {23, 5, 42, -1, 99}; Arrays.sort(numbersArray); System.out.println("Sorted Array: " + Arrays.toString(numbersArray)); // 输出: Sorted Array: [-1, 5, 23, 42, 99] // 3. 自定义排序规则(使用Comparator) List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David"); // 按字符串长度排序 Collections.sort(names, (a, b) -> a.length() - b.length()); // 或使用方法引用:Collections.sort(names, Comparator.comparingInt(String::length)); System.out.println("Sorted by length: " + names); // 输出: Sorted by length: [Bob, Alice, David, Charlie] 2. 搜索算法 (Searching) 核心类: java.util.Collections, java.util.Arrays Collections.binarySearch(List, Key) / Arrays.binarySearch(array, key) 用途: 在已排序的列表或数组中,使用二分查找算法快速定位元素。 重要前提: 集合或数组必须是有序的(通常是升序),否则结果不可预测。 返回值: 如果找到,返回元素的索引;如果未找到,返回一个负值,表示应插入的位置 (-(insertion point) - 1)。 时间复杂度: O(log n)。 示例代码: java List<Integer> sortedList = Arrays.asList(10, 20, 30, 40, 50); int index1 = Collections.binarySearch(sortedList, 30); System.out.println("Index of 30: " + index1); // 输出: 2 (找到了) int index2 = Collections.binarySearch(sortedList, 25); System.out.println("Index of 25: " + index2); // 输出: -3 (未找到。插入点应为 2, 所以返回 -2-1 = -3) int[] sortedArray = {10, 20, 30, 40, 50}; int index3 = Arrays.binarySearch(sortedArray, 40); System.out.println("Index of 40 in array: " + index3); // 输出: 3 3. 洗牌、填充与工具算法 核心类: java.util.Collections Collections.shuffle(List) 用途: 随机打乱列表中元素的顺序(洗牌)。 底层实现: 使用 Fisher-Yates shuffle 算法的高效变体,能产生均匀的随机排列。 Collections.reverse(List): 反转列表。 Collections.fill(List, obj): 用指定对象填充列表的所有元素。 Collections.copy(destList, srcList): 复制列表。 Collections.max(Collection) / Collections.min(Collection): 根据自然顺序查找最大/最小元素。 Collections.frequency(Collection, Object): 计算某元素出现的频率。 示例代码: java List<Integer> cards = new ArrayList<>(); for (int i = 1; i <= 10; i++) { cards.add(i); } System.out.println("Original deck: " + cards); Collections.shuffle(cards); System.out.println("Shuffled deck: " + cards); // 其他工具方法 Collections.reverse(cards); System.out.println("Reversed deck: " + cards); int max = Collections.max(cards); int frequencyOfFive = Collections.frequency(cards, 5); System.out.println("Max card: " + max + ", Frequency of 5: " + frequencyOfFive); 第二部分:核心基础 — 需要掌握的经典算法 虽然 JDK 提供了强大的工具,但许多算法思想需要开发者自己实现来解决特定问题。 1. 排序与搜索基础 理解这些基础算法的实现有助于深入理解算法思想。 冒泡排序 (Bubble Sort) 思想: 重复遍历列表,比较相邻元素,如果顺序错误就交换它们。 复杂度: O(n²)。(仅用于教学,实际开发切勿使用!) java public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { // 交换 arr[j] 和 arr[j+1] int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } 线性搜索 (Linear Search) 思想: 从头到尾遍历每个元素,直到找到目标。 复杂度: O(n)。适用于小规模或未排序的数据。 java public static int linearSearch(int[] arr, int target) { for (int i = 0; i < arr.length; i++) { if (arr[i] == target) { return i; // 找到,返回索引 } } return -1; // 未找到 } 2. 递归与分治 (Recursion & Divide and Conquer) 许多高效算法基于此思想。 经典案例:斐波那契数列 (Fibonacci Sequence) 问题: F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2) (n>=2)。 java // 简单递归(效率极低,存在大量重复计算) public static int fibonacciRecursive(int n) { if (n <= 1) return n; return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2); } // 使用动态规划(迭代+记忆化,高效) public static int fibonacciDP(int n) { if (n <= 1) return n; int[] dp = new int[n + 1]; dp[0] = 0; dp[1] = 1; for (int i = 2; i <= n; i++) { dp[i] = dp[i - 1] + dp[i - 2]; } return dp[n]; } 3. 图算法 (Graph Algorithms) Java 标准库没有图结构,需要自行建模(使用邻接表或邻接矩阵)并实现算法。 图的表示: java // 使用邻接表(最常用) // 1. 使用 Map 和 List Map<Integer, List<Integer>> graph = new HashMap<>(); // 2. 或创建一个 Node 类 class GraphNode { int val; List<GraphNode> neighbors; GraphNode(int x) { val = x; neighbors = new ArrayList<>(); } } // 使用二维数组(邻接矩阵)表示带权图 int[][] graphMatrix; 广度优先搜索 (BFS) - 寻找最短路径(无权图) 思想: 层层扩散,使用队列辅助。 java public int bfsShortestPath(Map<Integer, List<Integer>> graph, int start, int end) { Queue<Integer> queue = new LinkedList<>(); Set<Integer> visited = new HashSet<>(); Map<Integer, Integer> distance = new HashMap<>(); // 记录到起点的距离 queue.offer(start); visited.add(start); distance.put(start, 0); while (!queue.isEmpty()) { int currentNode = queue.poll(); if (currentNode == end) { return distance.get(currentNode); } for (int neighbor : graph.getOrDefault(currentNode, new ArrayList<>())) { if (!visited.contains(neighbor)) { visited.add(neighbor); queue.offer(neighbor); distance.put(neighbor, distance.get(currentNode) + 1); } } } return -1; // 未找到路径 } 4. 动态规划 (Dynamic Programming) 通过存储子问题的解来避免重复计算,从而高效解决复杂问题。 经典案例:爬楼梯问题 问题: 每次可以爬 1 或 2 个台阶,爬到 n 阶有多少种不同方法? 状态转移方程: dp[i] = dp[i-1] + dp[i-2] java public int climbStairs(int n) { if (n <= 2) return n; int[] dp = new int[n + 1]; dp[1] = 1; dp[2] = 2; for (int i = 3; i <= n; i++) { dp[i] = dp[i - 1] + dp[i - 2]; } return dp[n]; } // 可以进一步优化空间复杂度到 O(1),只保留前两个状态 总结与实践建议 场景 推荐做法 对集合/数组排序 永远优先使用 Collections.sort() 或 Arrays.sort()。 在有序数据中查找 使用 binarySearch()。 需要随机顺序 使用 Collections.shuffle()。 解决特定领域问题 (如最短路径、背包问题) 1. 首先寻找优秀的第三方库 (如 JGraphT for 图算法)。 2. 其次再考虑自己实现经典算法。 面试与学习 必须掌握如何从零实现各类经典算法 (快排归并、BFS/DFS、DP等)。 性能优化 理解算法复杂度 (Big O),这是选择合适算法和数据结构的根本依据。 核心思想: 不要重复造轮子。 在日常业务开发中,最大限度地利用 JDK 和成熟第三方库提供的稳定高效的算法实现。你的精力应该集中在正确地建模业务问题和选择最合适的工具(算法/数据结构) 上,而不是重新实现一个可能更差的排序算法。然而,深入理解这些轮子是如何造出来的,是你在遇到复杂问题、需要进行底层优化或通过技术面试时的必备能力。生成思维导图
09-16
基于遗传算法的微电网调度(风、光、蓄电池、微型燃气轮机)(Matlab代码实现)内容概要:本文档介绍了基于遗传算法的微电网调度模型,涵盖风能、太阳能、蓄电池和微型燃气轮机等多种能源形式,并通过Matlab代码实现系统优化调度。该模型旨在解决微电网中多能源协调运行的问题,优化能源分配,降低运行成本,提高可再生能源利用率,同时考虑系统稳定性与经济性。文中详细阐述了遗传算法在求解微电网多目标优化问题中的应用,包括编码方式、适应度函数设计、约束处理及算法流程,并提供了完整的仿真代码供复现与学习。此外,文档还列举了大量相关电力系统优化案例,如负荷预测、储能配置、潮流计算等,展示了广泛的应用背景和技术支撑。; 适合人群:具备一定电力系统基础知识和Matlab编程能力的研究生、科研人员及从事微电网、智能电网优化研究的工程技术人员。; 使用场景及目标:①学习遗传算法在微电网调度中的具体实现方法;②掌握多能源系统建模与优化调度的技术路线;③为科研项目、毕业设计或实际工程提供可复用的代码框架与算法参考; 阅读建议:建议结合Matlab代码逐段理解算法实现细节,重点关注目标函数构建与约束条件处理,同时可参考文档中提供的其他优化案例进行拓展学习,以提升综合应用能力。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值