22章 开发高效算法

最新推荐文章于 2024-10-16 18:20:22 发布
最新推荐文章于 2024-10-16 18:20:22 发布
阅读量605 收藏 11
点赞数 11
分类专栏： Java语言程序设计(原书第12版)进阶篇课后题 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61219098/article/details/142172417
版权

1.编写一个程序，提示用户输入一个字符串，然后显示最大连续递增的有序子字符串。分析你的程序的时间复杂度。

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		System.out.println("请输入字符串：");
		Scanner scanner = new Scanner(System.in);
		String s = scanner.nextLine();
		scanner.close();
		char pre_c = s.charAt(0);
		int m = 1, n = 1, mi = 1;
		for (int i = 1; i < s.length(); i++) {
			if (s.charAt(i) > pre_c)
				++n;
			else {
				if (m < n) {
					m = n;
					mi = i;
				}
				n = 1;
			}
			pre_c = s.charAt(i);
		}
		System.out.println("最大连续递增子串为：" + (n > m ? s.substring(s.length() - n) : s.substring(mi - m, mi)));
	}
}

时间复杂度为 O ( n ) O(n) O(n)，空间复杂度为 O ( 1 ) O(1) O(1)。

2.编写一个程序，提示用户输入一个字符串，然后显示最大连续递增的有序字符子序列。分析你的程序的时间复杂度。

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		System.out.println("请输入字符串：");
		Scanner scanner = new Scanner(System.in);
		String s = scanner.nextLine();
		scanner.close();
		if (s.isEmpty()) {
			System.out.println("最大连续递增的有序字符子序列为：");
			return;
		}
		int n = s.length();
		String[] d = new String[n]; // d[i] 表示第 i 个字符结尾的子序列
		for (int i = 0; i < n; i++) {
			char c = s.charAt(i);
			d[i] = String.valueOf(c);
			for (int j = 0; j < i; j++)
				if (s.charAt(j) < c && d[j].length() >= d[i].length())
					d[i] = d[j] + c;
		}
		String res = d[0];
		for (int i = 1; i < n; i++)
			if (d[i].length() > res.length())
				res = d[i];
		System.out.println("最大连续递增的有序字符子序列为：" + res);
	}
}

(动态规划)时间复杂度为 O ( n 2 ) O(n^2) O(n2)，空间复杂度为 O ( n ) O(n) O(n)。

3.编写一个时间复杂度为 O ( n ) O(n) O(n)的程序，提示用户输入两个字符串，然后检测第二个字符串是否为第一个字符串的子串。假定在字符串中相邻的字符是不同的。(不要使用String类中的indexOf方法)

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		System.out.println("请输入两个字符串");
		Scanner scanner = new Scanner(System.in);
		String s1 = scanner.nextLine();
		String s2 = scanner.nextLine();
		scanner.close();
		int i = KMP(s1, s2);
		System.out.println(i == -1 ? "不是子串！" : "在下标" + i + "处成功匹配！");
	}

	public static int KMP(String s, String p) {
		int[] next = KMP_next(p);
		int i = 0, j = 0, n = s.length(), m = p.length();
		while (i < n) {
			if (s.charAt(i) == p.charAt(j)) {
				++i;
				++j;
			} else if (j > 0)
				j = next[j - 1];
			else
				++i;
			if (j == m) return i - j;
		}
		return -1;
	}

	private static int[] KMP_next(String p) {
		int n = p.length(), i = 1, j = 0;
		int[] a = new int[n];
		while (i < n)
			if (p.charAt(j) == p.charAt(i))
				a[i++] = ++j;
			else if (j == 0)
				a[i++] = 0;
			else
				j = a[j - 1];
		return a;
	}
}

4.改进程序清单22-15中的Boyer-Moore算法实现，在 O ( 1 ) O(1) O(1)的时间内测试不匹配字符位于模式中的哪里，使用模式中所有字符组成的规则集。如果测试为假，算法可以将模式划过不匹配字符。

5.编写一个时间复杂度为 O ( n ) O(n) O(n)的程序，提示用户输入一个以0结束的整数序列，找出同样数字的最长连续子序列。

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		int pre = 0, index = -1;
		int current, currentIndex = 0, currentCount = 1;
		int maxNum = 0, maxIndex = 0, maxCount = 1;
		Scanner scanner = new Scanner(System.in);
		while ((current = scanner.nextInt()) != 0) {
			++index;
			if (current == pre) {
				++currentCount;
				continue;
			}
			if (currentCount > maxCount) {
				maxNum = pre;
				maxIndex = currentIndex;
				maxCount = currentCount;
			}
			currentIndex = index;
			currentCount = 1;
			pre = current;
		}
		scanner.close();
		System.out.printf("The longest same number sequence starts at index %d with %d values of %d.", maxIndex, maxCount, maxNum);
	}
}

6.编写一个程序，使用程序清单22-3和程序清单22-4中的算法，求下标从40到45的每两个连续的斐波那契数的GCD，并求其执行时间。

7.22.8节介绍了一个使用分治法求最近点对的算法。实现这个算法，使其满足下面的要求：

  • 定义一个名为Pair的类，其数据域p1和p2表示两个点，名为getDistance()的方法返回这两个点之间的距离。
  • 实现下面的方法：

7

import java.awt.geom.Point2D;

public class Pair {
	public Point2D p1, p2;

	public Pair(Point2D p1, Point2D p2) {
		this.p1 = p1;
		this.p2 = p2;
	}

	public double getDistance() {
		return Point2D.distance(p1.getX(), p1.getY(), p2.getX(), p2.getY());
	}

	public static Pair getClosestPair(double[][] points) {
		Closest2DPointsFinder<double[]> finder = new Closest2DPointsFinder<>(points) {
			@Override
			public double getX(double[] point) {
				return point[0];
			}

			@Override
			public double getY(double[] point) {
				return point[1];
			}
		};
		return finder.getClosestDistancePair();
	}

	public static Pair getClosestPair(Point2D[] points) {
		Closest2DPointsFinder<Point2D> finder = new Closest2DPointsFinder<>(points) {
			@Override
			public double getX(Point2D point) {
				return point.getX();
			}

			@Override
			public double getY(Point2D point) {
				return point.getY();
			}
		};
		return finder.getClosestDistancePair();
	}

	public static double distance(Point2D p1, Point2D p2) {
		return Point2D.distance(p1.getX(), p1.getY(), p2.getX(), p2.getY());
	}

	public static double distance(double x1, double y1, double x2, double y2) {
		return Point2D.distance(x1, y1, x2, y2);
	}
}

import java.awt.geom.Point2D;
import java.util.Comparator;

public abstract class Closest2DPointsFinder<E> extends ClosestPointsFinder<E> {
	public Closest2DPointsFinder(E[] points, Comparator<E> comparator) {
		super(points);
		super.init(comparator);
	}

	public Closest2DPointsFinder(E[] points) {
		super(points);
		super.init(new Comparator<E>() {
			@Override
			public int compare(E o1, E o2) {
				if (getX(o1) > getX(o2)) return 1;
				if (getX(o1) == getX(o2))
					if (getY(o1) > getY(o2))
						return 1;
					else if (getY(o1) == getY(o2))
						return 0;
				return -1;
			}
		});
	}

	public abstract double getY(E e);

	public Point2D toPoint2D(E e) {
		return new Point2D.Double(getX(e), getY(e));
	}

	@Override
	public double getDistance(E e1, E e2) {
		return Point2D.distance(getX(e1), getY(e1), getX(e2), getY(e2));
	}

	public Pair getClosestDistancePair() {
		ClosestPointsFinder<E>.PointsPairRef ref = getClosestDistance();
		return new Pair(toPoint2D(points[ref.p1Index]), toPoint2D(points[ref.p2Index]));
	}
}

import java.util.Arrays;
import java.util.Comparator;

public abstract class ClosestPointsFinder<E> {
	protected E[] points;

	public ClosestPointsFinder(E[] points) {
		this.points = points;
	}

	public void init(Comparator<E> comparator) {
		Arrays.sort(points, comparator);
	}

	public abstract double getDistance(E e1, E e2);

	public double getDistanceByIndex(int index1, int index2) {
		return getDistance(points[index1], points[index2]);
	}

	public abstract double getX(E e);

	public double getXByIndex(int index) {
		return getX(points[index]);
	}

	public class PointsPairRef {
		public int p1Index, p2Index;
		public double distance;

		public PointsPairRef(int p1, int p2, double d) {
			p1Index = p1;
			p2Index = p2;
			distance = d;
		}

		public PointsPairRef(int p1, int p2) {
			p1Index = p1;
			p2Index = p2;
			distance = getDistanceByIndex(p1, p2);
		}

		public PointsPairRef(int p) {
			p1Index = p2Index = p;
			distance = Double.MAX_VALUE;
		}

		public boolean isValid() {
			return p1Index != p2Index;
		}
	}

	private PointsPairRef getClosestDistance(int l, int r) {
		if (l + 1 >= r) return new PointsPairRef(l);
		if (l + 2 == r) return new PointsPairRef(l, l + 1);
		int m = (l + r) >> 1;
		PointsPairRef L = getClosestDistance(l, m), R = getClosestDistance(m + 1, r);
		double d, t;
		int m1, m2;
		if (L.isValid())
			if (R.isValid()) {
				if (L.distance > R.distance) {
					d = R.distance;
					m1 = R.p1Index;
					m2 = R.p2Index;
				} else {
					d = L.distance;
					m1 = L.p1Index;
					m2 = L.p2Index;
				}
				for (int i = binarySearch(l, m, d); i < m; i++) {
					double di = getDistanceByIndex(i, m);
					if (di < d) {
						d = di;
						m1 = i;
						m2 = m;
					}
				}
				for (int i = binarySearch(m + 1, r, d); i < r; i++) {
					double di = getDistanceByIndex(i, m);
					if (di < d) {
						d = di;
						m1 = i;
						m2 = m;
					}
				}
			} else {
				d = getDistanceByIndex(m, R.p1Index);
				m1 = m;
				m2 = R.p1Index;
				for (int i = binarySearch(l, m, d); i < m; i++) {
					double di = getDistanceByIndex(i, m);
					if (di < d) {
						d = di;
						m2 = i;
					}
				}
			}
		else if (R.isValid()) {
			d = getDistanceByIndex(m, L.p1Index);
			m1 = m;
			m2 = L.p1Index;
			for (int i = binarySearch(m + 1, r, d); i < r; i++) {
				double di = getDistanceByIndex(i, m);
				if (di < d) {
					d = di;
					m2 = i;
				}
			}
		} else {
			d = getDistanceByIndex(L.p1Index, m);
			t = getDistanceByIndex(R.p1Index, m);
			if (d > t) {
				d = getDistanceByIndex(L.p1Index, R.p1Index);
				return d > t ? new PointsPairRef(R.p1Index, m, t) : new PointsPairRef(L.p1Index, R.p1Index, d);
			} else {
				t = getDistanceByIndex(L.p1Index, R.p1Index);
				return d > t ? new PointsPairRef(L.p1Index, R.p1Index, t) : new PointsPairRef(L.p1Index, m, d);
			}
		}
		return new PointsPairRef(m1, m2, d);
	}

	private int binarySearch(int l, int r, double key) {
		--r;
		while (l <= r) {
			int m = (l + r) >> 1;
			if (getXByIndex(m) > key)
				r = m - 1;
			else
				l = m + 1;
		}
		return l;
	}

	public PointsPairRef getClosestDistance() {
		return getClosestDistance(0, points.length);
	}
}

8.编写一个程序，找出不大于10 000 000 000的所有素数。大概有455 052 511个这样的素数。你的程序应该满足下面的要求：

  • 应该将这些素数都存储在一个名为PrimeNumber.dat的二进制数据文件中。当找到一个新素数时，将该数字追加到这个文件中。
  • 为了判断一个新的数是否为素数，程序应该从数据文件加载这些素数到一个大小为10000的long型数组。如果数组中没有任何数是这个新数的除数，继续从该数据文件中读取接下来的10000个素数，直到找到除数或者读取完文件中的所有数字。如果没找到除数，这个新的数字就是素数。
  • 因为执行该程序要花很长时间，所以应该把它作为UNIX机器上的一个批处理任务来运行。如果机器被关闭或重启，程序应该使用二进制数据文件中存储的素数来继续，而不是从零开始启动。
import java.io.*;

public class PrimeFinder {
	private int bufferSize;
	private RandomAccessFile primesFile;
	private long currentNumber;
	private long maxNumber;
	private long[] buffer;

	public PrimeFinder(String fileName, long maxNumber, int bufferSize) throws IOException {
		this.maxNumber = maxNumber;
		this.bufferSize = bufferSize;
		try {
			primesFile = new RandomAccessFile(fileName, "rw");
			if (primesFile.length() == 0L) {
				currentNumber = 3L;
				primesFile.writeLong(2L);
			} else
				try {
					primesFile.seek(primesFile.length() - Long.BYTES);
					currentNumber = primesFile.readLong();
				} catch (IOException e) {
					currentNumber = 3L;
					primesFile.writeLong(2L);
				}
		} catch (FileNotFoundException e) {
			File file = new File(fileName);
			file.createNewFile();
			primesFile = new RandomAccessFile(file, "rw");
			currentNumber = 3L;
			primesFile.writeLong(2L);
		} finally {
			buffer = new long[bufferSize];
		}
	}

	public PrimeFinder(String fileName, long maxNumber) throws IOException {
		this(fileName, maxNumber, 10000);
	}

	public PrimeFinder(String fileName) throws IOException {
		this(fileName, 10000000000L);
	}

	public PrimeFinder() throws IOException {
		this("PrimeNumber.dat");
	}

	private static boolean isnPrimeInBuffer(long number, long[] buffer, int size) {
		for (int i = 0; i < size; i++)
			if (number % buffer[i] == 0L)
				return true;
		return false;
	}

	private boolean isPrime() throws IOException {
		int currentBufferSize = 0;
		primesFile.seek(0L);
		boolean isnEOF = true;
		do {
			do
				try {
					buffer[currentBufferSize] = primesFile.readLong();
				} catch (EOFException e) {
					isnEOF = false;
					break;
				}
			while (++currentBufferSize < bufferSize);
			if (isnPrimeInBuffer(currentNumber, buffer, currentBufferSize)) return false;
			currentBufferSize = 0;
		} while (isnEOF);
		return true;
	}

	public void findPrimes() throws IOException {
		while (currentNumber < maxNumber) {
			if (isPrime()) primesFile.writeLong(currentNumber);
			currentNumber += 2;
		}
		primesFile.close();
	}
}

9.编写一个程序，利用卷包裹算法为点集找到凸包。

import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.List;

public abstract class GiftWrapper<E> {
	public abstract double getX(E e);

	public abstract double getY(E e);

	public Point2D toPoint2D(E e) {
		return new Point2D.Double(getX(e), getY(e));
	}

	// 生成的列表是原数组元素的浅拷贝
	public ArrayList<E> getConvexHull(E[] points) {
		int n = points.length;
		if (n < 4) return new ArrayList<>(List.of(points));
		ArrayList<E> list = new ArrayList<>();
		int firstIndex = getRightLowestPointIndex(points), preIndex = firstIndex;
		E prePoint = points[firstIndex];
		do {
			list.add(prePoint);
			int i = preIndex == 0 ? 1 : 0;
			double mx = getX(points[i]) - getX(prePoint), my = getY(points[i]) - getY(prePoint);
			for (int j = i + 1; j < n; j++) {
				if (j == preIndex) continue;
				double jx = getX(points[j]) - getX(prePoint), jy = getY(points[j]) - getY(prePoint);
				if (onRight(mx, my, jx, jy)) {
					i = j;
					mx = jx;
					my = jy;
				}
			}
			prePoint = points[preIndex = i];
		} while (preIndex != firstIndex);
		return list;
	}

	public ArrayList<Point2D> getConvexHullPoint2D(E[] points) {
		int n = points.length;
		if (n < 4) {
			ArrayList<Point2D> list = new ArrayList<>();
			for (E e : points) list.add(toPoint2D(e));
			return list;
		}
		ArrayList<Point2D> list = new ArrayList<>();
		int firstIndex = getRightLowestPointIndex(points), preIndex = firstIndex;
		E prePoint = points[firstIndex];
		do {
			list.add(toPoint2D(prePoint));
			int i = preIndex == 0 ? 1 : 0;
			double mx = getX(points[i]) - getX(prePoint), my = getY(points[i]) - getY(prePoint);
			for (int j = i + 1; j < n; j++) {
				if (j == preIndex) continue;
				double jx = getX(points[j]) - getX(prePoint), jy = getY(points[j]) - getY(prePoint);
				if (onRight(mx, my, jx, jy)) {
					i = j;
					mx = jx;
					my = jy;
				}
			}
			prePoint = points[preIndex = i];
		} while (preIndex != firstIndex);
		return list;
	}

	// 判断向量2是否在向量1的右侧
	private static boolean onRight(double vector1X, double vector1Y, double vector2X, double vector2Y) {
		// 旋转坐标系使得第1个向量位于第1象限
		if (vector1X < 0)
			if (vector1Y < 0) {
				vector1X = -vector1X;
				vector1Y = -vector1Y;
				vector2X = -vector2X;
				vector2Y = -vector2Y;
			} else {
				double t = vector1Y;
				vector1Y = -vector1X;
				vector1X = t;
				t = vector2Y;
				vector2Y = -vector2X;
				vector2X = t;
			}
		else if (vector1Y < 0) {
			double t = vector1X;
			vector1X = -vector1Y;
			vector1Y = t;
			t = vector2X;
			vector2X = -vector2Y;
			vector2Y = t;
		}
		if (vector2X < 0)
			if (vector2Y > 0)
				return false;
			else
				return vector2X * vector1Y > vector2Y * vector1X;
		else if (vector2Y < 0)
			return true;
		else {
			if (vector2X == 0 && vector1X == 0) return vector2Y > vector1Y;
			vector1Y *= vector2X;
			vector2Y *= vector1X;
			return vector1Y == vector2Y ? vector2X > vector1X : vector1Y > vector2Y;
		}
	}

	private int getRightLowestPointIndex(E[] points) {
		int n = points.length;
		int r = 0;
		for (int i = 1; i < n; i++)
			if (getY(points[i]) < getY(points[r]) || getY(points[i]) == getY(points[r]) && getX(points[i]) > getX(points[r]))
				r = i;
		return r;
	}
}

测试程序：

import java.awt.geom.Point2D;
import java.util.ArrayList;

public class Test {
	public static void main(String[] args) {
		double[][] points = {{1, 2.4}, {2.5, 2}, {1.5, 34.5}, {5.5, 6}, {6, 2.4}, {5.5, 9}};
		ArrayList<Point2D> res = new GiftWrapper<double[]>() {
			@Override
			public double getX(double[] point) {
				return point[0];
			}

			@Override
			public double getY(double[] point) {
				return point[1];
			}
		}.getConvexHullPoint2D(points);
		for (Point2D p : res) System.out.printf("(%f,%f)\n", p.getX(), p.getY());
	}
}
zsc_118
关注
专栏目录
算法心得：高效算法的奥秘
03-11
本书《算法心得：高效算法的奥秘》由一位在IBM工作超过50年的资深计算机专家撰写，是算法领域具有重要影响力的著作之一。根据描述，书中系统性地介绍了高效、优雅且巧妙的算法，并从数学的角度对这些算法背后的原理...
算法竞赛入门经典授课教案第8章 高效算法设计.doc
05-08
《算法竞赛入门经典授课教案第8章 高效算法设计》着重讲解了设计高效算法的策略，主要包括算法分析、排序与搜索、递归与分治以及贪心法四大主题。这些内容是算法竞赛和实际编程中至关重要的技能。 首先，算法分析是...
高效算法-C/C++开发
05-26
数据结构和算法清洁用不同语言编写的数据结构和算法的示例实现。 实现列表算法列表（未更新）贡献！ Con数据结构和算法使用不同语言编写的数据结构和算法的干净示例实现。 实现列表算法列表（未更新）贡献！ 始终...
KMP算法：高效字符串匹配算法详解
04-03
KMP算法（Knuth-Morris-Pratt算法）是一种高效的字符串匹配算法，由Donald Knuth、Vaughan Pratt和James H. Morris共同发明。KMP算法通过使用一个称为“部分匹配表”或“next数组”的数组来减少字符串匹配过程中的...
VisionMaster算法平台SDK开发指南V4.3.1（.NET）
01-24
海康威视VisionMaster SDK是一款专为开发者设计的软件开发工具包，用于实现与海康威视设备的高效交互，特别是在视频处理、图像分析以及智能算法应用方面。此SDK提供了丰富的功能接口，使得开发者能够基于.NET框架...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 323
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 391
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 702
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 690
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 548
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 910
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
spring task的使用场景
qq_40603125的博客
10-13 356
spring任务调度框架约定的时间。
Hex编码
weixin_74305514的博客
10-13 294
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
pyserini安装&使用
DreamLike_zzg的博客
10-14 609
代码。
JavaWeb Servlet--09深入：注册系统04--修改页面
weixin_62189092的博客
10-16 362
这里就会获取要修改的用户的id，返回用户，再把这个用户重定向跳转到update.jsp页面。在再UserServlet里书写修改的代码。分析：点击修改超链接，就跳转到一个修改界面，要显示原本的数据，且密码显示出来，在该页面将对用户的数据的进行修改，最后提交。findUserByID()----显示原本的内容，update()---修改数据库内容的方法。注意：修改信息是要展示密码的文本内容，所以在password处type="text";写法和register没有太大的区别，主要是对文本框获得值。
java在线招投标|评标|竞标|单一采购|邀标|评审专家|采购软件源码
最新发布
m0_72864708的博客
10-16 316
主要功能包含：招标公告管理、变更公告管理、终止公告管理、中标候选人公告管理、中标公告管理、采购公告管理、采购结果公告管理、单一来源采购结果公告管理。3、采购项目管理：可对项目采购过程全流程管理，包含功能有：评审人员的选取/抽取、基准价维护、供应商缴费审核、投标过程记录查询、供应商报价维护、项目评审查询、线下项目管理、采购计划制定与维护。主要功能包含：公告模板管理、评审人员管理、第三方机构管理、供应商管理、采购类别设置、评审模板管理、考核模板管理。主要板块包含：招标公告、非招标公告、系统通知、政策法规。
JavaSE——认识异常
wx2023_10_15的博客
10-12 973
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
初始Python篇（2）——逻辑控制、序列
我要学编程的博客
10-14 1223
程序的组织结构：顺序、选择、循环 pass空语句 猜数字小游戏 序列、序列相关操作
java工具类判断一个点是否在多边形内
weixin_47315082的博客
10-15 198
最近在做的项目，需要画一个多边形范围，并且判断当前定位是否在这个范围内，进出需要提醒，因此写了一个工具类判断一个点是否在多边形内，记录一下。
算法技术手册：高效软件开发的实用指南
通过实例和清晰的代码示例，读者可以学习到如何将这些算法应用于实际软件开发中。 在排序算法方面，读者会接触到快速排序、归并排序、堆排序等经典方法，理解它们的时间复杂度和空间复杂度，以及在特定情况下的优...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zsc_118

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值