22章 开发高效算法

news2024/11/24 10:53:24

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());
	}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2142850.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

这个公司可以做点什么呢？

这个公司可以做点什么呢？

我是穿拖鞋的汉子&#xff0c;魔都中坚持长期主义的汽车电子工程师。 老规矩&#xff0c;分享一段喜欢的文字&#xff0c;避免自己成为高知识低文化的工程师&#xff1a; 屏蔽力是信息过载时代一个人的特殊竞争力&#xff0c;任何消耗你的人和事&#xff0c;多看一眼都是你的不…
阅读更多...
国学盛典 致敬先贤 《老子与道德经》纪录片研讨会在北京善品堂国学馆圆满落幕

国学盛典 致敬先贤 《老子与道德经》纪录片研讨会在北京善品堂国学馆圆满落幕

9月10日&#xff0c;《老子与道德经》纪录片研讨会在北京善品堂国学馆圆满落幕。中国著名表演艺术家、曾饰演央视86版电视剧《西游记》中“孙悟空”的六小龄童先生与两百余人传统文化传播者、践行者、爱好者齐聚一堂&#xff0c;共同交流。本次会议由中国文化促进会福文化工作委…
阅读更多...
python-在PyCharm中使用PyQt5

python-在PyCharm中使用PyQt5

文章目录 1. 安装 PyQt5 和QtTools2. QtDesigner 和 PyUIC 的环境配置2.1 在 PyCharm 添加 Create Tools2.2 添加 PyUIC 工具 3. 创建ui界面4. 使用python调用ui界面参考文献 1. 安装 PyQt5 和QtTools QT 是最强大的 GUI 库之一&#xff0c;PyQt5 是 Python 绑定 QT5 应用的框…
阅读更多...
phpstudy 建站使用 php8版本打开 phpMyAdmin后台出现网页提示致命错误：（phpMyAdmin这是版本问题导致的）

phpstudy 建站使用 php8版本打开 phpMyAdmin后台出现网页提示致命错误：（phpMyAdmin这是版本问题导致的）

报错提示&#xff1a; 解决方法&#xff1a;官网下载phpmyadmin 5.2.1版本。 下载地址&#xff1a;phpMyAdmin 将网站根目录phpMyAdmin4.8.5里面的文件换成 官网下载的5.2.1版本即可。 重启网站&#xff0c;打开phpMyAdmin后台即可&#xff08;若打不开更改 mysql密码即可&am…
阅读更多...
传知代码-KAN卷积：医学图像分割新前沿

传知代码-KAN卷积：医学图像分割新前沿

代码以及视频讲解 本文所涉及所有资源均在传知代码平台可获取 概述 在本文中深入探讨KAN卷积在医学图像分割领域的创新应用&#xff0c;特别是通过引入Tokenized KAN Block&#xff08;Tok Kan&#xff09;这一突破性设计&#xff0c;将深度学习中的图像分割技术推向了新的高…
阅读更多...
代理导致的git错误

代理导致的git错误

问题&#xff1a; 今天在clone时出现如下错误&#xff1a; fatal: unable to access https://github.com/NirDiamant/RAG_Techniques.git/: Failed to connect to 127.0.0.1 port 10089 after 2065 ms: Couldnt connect to server真是让人感到奇怪&#xff01;就在前天&#…
阅读更多...
Typora安装，使用，图片加载全流程

Typora安装，使用，图片加载全流程

文章目录 前言&#xff1a;安装&#xff1a;破解&#xff1a;使用typora&#xff1a;关于CSDN加载不出图片&#xff1a;创建OSS&#xff1a;设置PicGo&#xff1a; 前言&#xff1a; ​ Typora是一款非常流行的Markdown编辑器&#xff0c;简单来说就是可以方便我们写博客。拿我…
阅读更多...
Linux基础---07文件传输及解决yum安装失效的方法

Linux基础---07文件传输及解决yum安装失效的方法

Linux文件传输地图如下&#xff0c;先选取你所需的场景&#xff0c;若你是需要Linux和Linux之间传输文件就查看SCP工具即可。 一.下载网站文件 前提是有网&#xff1a; 检查网络是否畅通命令&#xff1a;ping www.baidu.com&#xff0c;若有持续的返回值就说明网络畅通。Ctr…
阅读更多...
如何建立一个Webservice WSDL的简单例子(完整例子)

如何建立一个Webservice WSDL的简单例子(完整例子)

一&#xff1a;根据对方给的wsdl 的接口地址创建Web 的逻辑端口 1&#xff1a;例如这个用C#写的Web 2.我们需要在SAP里建立一个Service Consumers 的服务记得后缀要加?wsdl 2&#xff1a;然后就会生成对应方法的出参 入参 返回的消息根据接口方法来判断 二&#xff1a;如何通…
阅读更多...
day21JS-axios数据通信

day21JS-axios数据通信

1. 什么是axios axios 是一个基于Promise 用于浏览器和 nodejs 的 HTTP 客户端&#xff0c;简单的理解就是ajax的封装&#xff0c;只不过它是Promise的实现版本。 特性&#xff1a; 从浏览器中创建 XMLHttpRequests从 node.js 创建 http 请求支持 Promise API拦截请求和响应转…
阅读更多...
基于Java的固定资产管理系统

基于Java的固定资产管理系统

基于Java的固定资产管理系统是一个实用的应用程序&#xff0c;用于跟踪和管理公司的资产。这种系统可以包括资产的采购日期、位置、状态、折旧等信息。下面是一个简单的固定资产管理系统的设计概述&#xff0c;以及一些关键功能模块的实现思路。 系统设计概览 用户管理&…
阅读更多...
2-97 基于matlab的小波变换模量最大值 （WTMM） 方法进行图像边缘检测

2-97 基于matlab的小波变换模量最大值 （WTMM） 方法进行图像边缘检测

基于matlab的小波变换模量最大值 &#xff08;WTMM&#xff09; 方法进行图像边缘检测。利用小波基函数的局部化和振荡特性来检测图像中的边缘&#xff0c;沿每个像素的梯度方向搜索局部最大值&#xff0c;保留局部最大值&#xff0c;抑制其他系数&#xff0c;实现边缘检测。程…
阅读更多...
一文入门生成式AI（理解ChatGPT的原理）

一文入门生成式AI（理解ChatGPT的原理）

一、什么是生成式AI&#xff1f; 以ChatGPT为代表的生成式AI&#xff0c;是对已有的数据和知识进行向量化的归纳&#xff0c;总结出数据的联合概率。从而在生成内容时&#xff0c;根据用户需求&#xff0c;结合关联字词的概率&#xff0c;生成新的内容。 可以这么联想&#x…
阅读更多...
(9) protobuf 与cmake

(9) protobuf 与cmake

文章目录 概要整体架构流程代码优化 概要 protobuf的安装与用cmake编译protobuf程序 整体架构流程 安装protobuf3 21.12&#xff0c;最新版本好像要用到一个新的库&#xff0c;有点麻烦。 https://github.com/protocolbuffers/protobuf/releases/tag/v21.12 all和cpp后缀的包…
阅读更多...
python植物大战僵尸项目源码【免费】

python植物大战僵尸项目源码【免费】

植物大战僵尸是一款经典的塔防游戏&#xff0c;玩家通过种植各种植物来抵御僵尸的进攻。 源码下载地址&#xff1a; 植物大战僵尸项目源码 提取码: 8muq
阅读更多...
【前端】prop传值的用法

【前端】prop传值的用法

prop配置项的作用是让组件接收外部传过来的值。 组件标签上传值给vue组件对象 <script> export default {name: HelloWorld,data(){return{ }},props:[name,age] #简单接收 } </script>方式2:利用对象方式设置数据类型进行类型限制 props:{name:String…
阅读更多...
kubernetes中pause容器的作用与源码详解

kubernetes中pause容器的作用与源码详解

概述 摘要&#xff1a;上一篇文章我们介绍了kubernetes是如何通过pause容器来构建一个pod。本文我们对pause容器做一个总结&#xff0c;并再此基础上次深入浅出&#xff0c;从pause容器的源码详细了解pause容器的实现原理。 正文 pause容器是什么 在 Kubernetes 中&#xff…
阅读更多...
echarts 实现中国geo地图自定义贴图实例

echarts 实现中国geo地图自定义贴图实例

文章目录 1. 实现效果2. 设置自定义图片&#xff0c;做好准备3. echarts 实现贴图 1. 实现效果 实现自定义背景图&#xff0c;给echarts地图贴背景图效果&#xff0c; 先准备两张背景图片&#xff0c;一张是默认的&#xff0c;一张是鼠标悬浮替换的&#xff0c;如下两张图 2.…
阅读更多...
基于EchoMimic加速版，可编辑标志点控制实现逼真音频驱动的肖像动画

基于EchoMimic加速版，可编辑标志点控制实现逼真音频驱动的肖像动画

EchoMimic 是蚂蚁集团终端技术部门开发的一项技术，旨在通过音频驱动生成逼真的肖像动画。对于那些初次接触这项技术的用户，本教程将带你逐步了解如何设置开发环境、获取项目代码、安装依赖，并最终成功运行示例生成自己的肖像动画。 文章目录 项目代码安装依赖业务拓展参数调…
阅读更多...
webpack的热更新原理

webpack的热更新原理

Webpack热更新&#xff08; Hot Module Replacement&#xff0c;简称 HMR&#xff09;&#xff0c;无需完全刷新整个页面的同时&#xff0c;更新所有类型的模块&#xff0c;是 Webpack 提供的最有用的功能之一。 保留在完全重新加载页面期间丢失的应用程序状态。只更新变更内容…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023