project euler 61

最新推荐文章于 2019-01-01 15:03:39 发布
最新推荐文章于 2019-01-01 15:03:39 发布
阅读量332 收藏
点赞数
分类专栏： project euler
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whuawell/article/details/50211379
版权

Problem 61

Cyclical figurate numbers

Triangle, square, pentagonal, hexagonal, heptagonal, and octagonal numbers are all figurate (polygonal) numbers and are generated by the following formulae:

     
Triangle P3,n=n(n+1)/2 1, 3, 6, 10, 15, …
Square P4,n=n2 1, 4, 9, 16, 25, …
Pentagonal P5,n=n(3n−1)/2 1, 5, 12, 22, 35, …
Hexagonal P6,n=n(2n−1) 1, 6, 15, 28, 45, …
Heptagonal P7,n=n(5n−3)/2 1, 7, 18, 34, 55, …
Octagonal P8,n=n(3n−2) 1, 8, 21, 40, 65, …

The ordered set of three 4-digit numbers: 8128, 2882, 8281, has three interesting properties.

  1. The set is cyclic, in that the last two digits of each number is the first two digits of the next number (including the last number with the first).
  2. Each polygonal type: triangle (P3,127=8128), square (P4,91=8281), and pentagonal (P5,44=2882), is represented by a different number in the set.
  3. This is the only set of 4-digit numbers with this property.

Find the sum of the only ordered set of six cyclic 4-digit numbers for which each polygonal type: triangle, square, pentagonal, hexagonal, heptagonal, and octagonal, is represented by a different number in the set.

循环的多边形数

三角形数、正方形数、五边形数、六边形数、七边形数和八边形数统称为多边形数。它们分别由如下的公式给出：

     
三角形数 P3,n=n(n+1)/2 1, 3, 6, 10, 15, …
正方形数 P4,n=n2 1, 4, 9, 16, 25, …
五边形数 P5,n=n(3n−1)/2 1, 5, 12, 22, 35, …
六边形数 P6,n=n(2n−1) 1, 6, 15, 28, 45, …
七边形数 P7,n=n(5n−3)/2 1, 7, 18, 34, 55, …
八边形数 P8,n=n(3n−2) 1, 8, 21, 40, 65, …

由三个4位数8128、2882、8281构成的有序集有如下三个有趣的性质。

  1. 这个集合是循环的，每个数的后两位是后一个数的前两位（最后一个数的后两位也是第一个数的前两位）。
  2. 每种多边形数——三角形数（P3,127=8128）、正方形数（P4,91=8281）和五边形数（P5,44=2882）——在其中各有一个代表。
  3. 这是唯一一个满足上述性质的4位数有序集。

存在唯一一个包含六个4位数的有序循环集，每种多边形数——三角形数、正方形数、五边形数、六边形数、七边形数和八边形数——在其中各有一个代表。求这个集合的元素和。

package projecteuler;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import junit.framework.TestCase;

public class Prj61 extends TestCase {

	public static int NUM_OF_SIZE = 6;

	public void testCyclicalFigurateNumbers() {

		DfsCyclicalFigurateNumbers2 dfsC2 = new DfsCyclicalFigurateNumbers2();
		dfsC2.doTest();

		/**
		 * 分层搜索,计算量太大,改为起始点固定，一步一步只要保持前一个最后两位和后一个量前两位相同即可.(只需保持一个使用类型标识,下次选取不同即可
		 * ，减小搜索深度和复杂度)
		 */
		// DfsCyclicalFigurateNumbers dfsC = new DfsCyclicalFigurateNumbers();
		// dfsC.doTest();
	}

	public interface ICalculateDataList {
		public List<Integer> getDataList(int start, int end);
	}

	public static class CyclicalFigurateNumbersTestCase2 {
		public int n;
		public int[] data;
		public int[] idx;

		public CyclicalFigurateNumbersTestCase2(int n) {
			super();
			this.n = n;
			data = new int[n];
			idx = new int[n];
		}

		public void setValue(int id, int val, int mapId) {
			data[id] = val;
			idx[id] = mapId;
		}

		public int[] getResult() {
			return Arrays.copyOf(data, data.length);
		}

		public boolean isOutOfBoundary(int id) {
			return id >= data.length;
		}

		public boolean isFind() {

			int[] _front = splitInt(data[0]);
			int[] _tail = splitInt(data[NUM_OF_SIZE - 1]);
			return _front[0] == _tail[1];

		}

		public boolean isValidMap(int id, int mapId) {
			for (int i = 0; i < id; i++) {
				if (idx[i] == mapId) {
					return false;
				}
			}
			return true;
		}

		public boolean isValid(int id, int val) {

			if (id == 0) {
				return true;
			}

			int[] _front = splitInt(data[id - 1]);
			int[] _tail = splitInt(val);
			return _front[1] == _tail[0];

		}

		public void printResult() {
			for (int i = 0; i < data.length; i++) {
				System.out.print(data[i] + ",");
			}
			System.out.println();
			for (int i = 0; i < idx.length; i++) {
				System.out.print(idx[i] + ",");
			}
			System.out.println();
		}
	}

	public static class DfsCyclicalFigurateNumbers2 {
		public List<int[]> rsList = new ArrayList<int[]>();

		public void doTest() {

			ICalculateDataList Octagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (3 * n - 2);
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Heptagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (5 * n - 3) / 2;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Hexagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (2 * n - 1);
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Pentagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (3 * n - 1) / 2;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Square = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * n;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Triangle = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (n + 1) / 2;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			Map<Integer, List<Integer>> mapList = new HashMap<Integer, List<Integer>>();
			mapList.put(0, Octagonal.getDataList(1000, 9999));
			mapList.put(1, Heptagonal.getDataList(1000, 9999));
			mapList.put(2, Hexagonal.getDataList(1000, 9999));
			mapList.put(3, Pentagonal.getDataList(1000, 9999));
			mapList.put(4, Square.getDataList(1000, 9999));
			mapList.put(5, Triangle.getDataList(1000, 9999));
			// mapList.put(0, Pentagonal.getDataList(1000, 9999));
			// mapList.put(1, Square.getDataList(1000, 9999));
			// mapList.put(2, Triangle.getDataList(1000, 9999));

			CyclicalFigurateNumbersTestCase2 ts = new CyclicalFigurateNumbersTestCase2(
					NUM_OF_SIZE);

			dfs(0, ts, mapList, rsList);

			System.out.println("result=_____________");
			for (int i = 0; i < rsList.size(); i++) {
				int[] rs = rsList.get(i);
				for (int j = 0; j < rs.length; j++) {
					System.out.print(rs[j] + ",");
				}
				System.out.println();
			}

		}

		private void dfs(int startIndex, CyclicalFigurateNumbersTestCase2 ts,
				Map<Integer, List<Integer>> mapList, List<int[]> rs) {

			if (ts.isOutOfBoundary(startIndex)) {
				if (ts.isFind()) {
					rs.add(ts.getResult());
					ts.printResult();
				}
				return;
			}

			if (startIndex == 0) {
				List<Integer> primeList = mapList.get(startIndex);
				for (int i = 0; i < primeList.size(); i++) {

					int setVal = primeList.get(i);
					if (ts.isValid(startIndex, setVal)) {
						ts.setValue(startIndex, setVal, 0);
						dfs(startIndex + 1, ts, mapList, rs);
					}
				}

			} else {

				for (Entry<Integer, List<Integer>> entry : mapList.entrySet()) {

					if (!ts.isValidMap(startIndex, entry.getKey())) {
						continue;
					}

					List<Integer> primeList = entry.getValue();
					for (int i = 0; i < primeList.size(); i++) {

						int setVal = primeList.get(i);
						if (ts.isValid(startIndex, setVal)) {
							ts.setValue(startIndex, setVal, entry.getKey());
							dfs(startIndex + 1, ts, mapList, rs);
						}
					}

				}

			}

		}
	}

	public static class CyclicalFigurateNumbersTestCase {
		public int n;
		public int[] data;

		public CyclicalFigurateNumbersTestCase(int n) {
			super();
			this.n = n;
			data = new int[n];
		}

		public void setValue(int id, int val) {
			data[id] = val;
		}

		public int[] getResult() {
			return Arrays.copyOf(data, data.length);
		}

		public boolean isOutOfBoundary(int id) {
			return id >= data.length;
		}

		public boolean isFind() {

			Combination cb = new Combination(data.length, 0);
			List<int[]> allCbs = cb.generateCom();
			for (int i = 0; i < allCbs.size(); i++) {
				int[] arr = allCbs.get(i);
				int[] tp = new int[arr.length];
				for (int j = 0; j < arr.length; j++) {
					tp[j] = data[arr[j]];
				}
				if (isCheckOK(tp)) {
					return true;
				}
			}

			return false;

		}

		private boolean isCheckOK(int[] tp) {

			for (int i = 0; i < tp.length - 1; i++) {
				int[] _front = splitInt(tp[i]);
				int[] _tail = splitInt(tp[i + 1]);

				if (_tail[0] != _front[1]) {
					return false;
				}
			}

			int[] _front = splitInt(tp[0]);
			int[] _tail = splitInt(tp[tp.length - 1]);
			return _front[0] == _tail[1];
		}

		public boolean isValid(int id, int val) {
			return true;
		}

		public void printResult() {
			for (int i = 0; i < data.length; i++) {
				System.out.print(data[i] + ",");
			}
			System.out.println();
		}
	}

	public static class DfsCyclicalFigurateNumbers {

		public List<int[]> rsList = new ArrayList<int[]>();

		public void doTest() {

			ICalculateDataList Octagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (3 * n - 2);
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Heptagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (5 * n - 3) / 2;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Hexagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (2 * n - 1);
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Pentagonal = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (3 * n - 1) / 2;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Square = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * n;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			ICalculateDataList Triangle = new ICalculateDataList() {

				@Override
				public List<Integer> getDataList(int start, int end) {
					List<Integer> dataList = new ArrayList<Integer>();
					for (int n = 1;; n++) {
						int val = n * (n + 1) / 2;
						if (val >= start) {
							if (val > end) {
								break;
							}
							int[] _val = splitInt(val);
							if (_val[0] >= 10 && _val[1] >= 10) {
								dataList.add(val);
							}
						}
					}
					return dataList;
				}
			};

			Map<Integer, List<Integer>> mapList = new HashMap<Integer, List<Integer>>();
			mapList.put(0, Octagonal.getDataList(1000, 9999));
			mapList.put(1, Heptagonal.getDataList(1000, 9999));
			mapList.put(2, Hexagonal.getDataList(1000, 9999));
			mapList.put(3, Pentagonal.getDataList(1000, 9999));
			mapList.put(4, Square.getDataList(1000, 9999));
			mapList.put(5, Triangle.getDataList(1000, 9999));
			// mapList.put(0, Pentagonal.getDataList(1000, 9999));
			// mapList.put(1, Square.getDataList(1000, 9999));
			// mapList.put(2, Triangle.getDataList(1000, 9999));

			CyclicalFigurateNumbersTestCase ts = new CyclicalFigurateNumbersTestCase(
					NUM_OF_SIZE);

			dfs(0, ts, mapList, rsList);

			System.out.println("result=_____________");
			for (int i = 0; i < rsList.size(); i++) {
				int[] rs = rsList.get(i);
				for (int j = 0; j < rs.length; j++) {
					System.out.print(rs[j] + ",");
				}
				System.out.println();
			}

		}

		private void dfs(int startIndex, CyclicalFigurateNumbersTestCase ts,
				Map<Integer, List<Integer>> mapList, List<int[]> rs) {

			if (ts.isOutOfBoundary(startIndex)) {
				ts.printResult();
				if (ts.isFind()) {
					rs.add(ts.getResult());
					ts.printResult();
				}
				return;
			}

			List<Integer> primeList = mapList.get(startIndex);
			for (int i = 0; i < primeList.size(); i++) {

				int setVal = primeList.get(i);
				if (ts.isValid(startIndex, setVal)) {
					ts.setValue(startIndex, setVal);
					dfs(startIndex + 1, ts, mapList, rs);
				}
			}

		}
	}

	public static int[] splitInt(int val) {
		String str = Integer.toString(val);
		return new int[] { Integer.parseInt(str.substring(0, 2)),
				Integer.parseInt(str.substring(2, str.length())) };
	}

	public static class Combination {
		private int[] startArr;

		public Combination(int size) {

			this(size, 1);
		}

		public Combination(int size, int startNum) {
			startArr = new int[size];
			for (int i = 0; i < size; i++) {
				startArr[i] = i + startNum;
			}
		}

		public List<int[]> generateCom() {
			List<int[]> ret = new ArrayList<int[]>();

			ret.add(Arrays.copyOf(startArr, startArr.length));

			while (true) {

				int lastAsc = findLastAsc(startArr);

				if (lastAsc == -1) {
					break;
				}

				int lasBigThanAsc = findBigThanAsc(startArr, lastAsc);

				exchangeEach(lastAsc, lasBigThanAsc, startArr);

				ret.add(Arrays.copyOf(startArr, startArr.length));
			}

			return ret;
		}

		private int findBigThanAsc(int[] startArr2, int lastAsc) {
			int i = 0;
			for (i = startArr2.length - 1; i > lastAsc; i--) {
				if (startArr2[i] > startArr2[lastAsc]) {
					return i;
				}
			}

			assert (i > lastAsc);
			return i;
		}

		private void exchangeEach(int lastAsc, int lasBigThanAsc,
				int[] startArr2) {

			int temp = startArr2[lastAsc];
			startArr2[lastAsc] = startArr2[lasBigThanAsc];
			startArr2[lasBigThanAsc] = temp;

			int[] sortArr = getCopyArr(lastAsc + 1, startArr2);

			for (int i = 0; i < sortArr.length / 2; i++) {

				temp = sortArr[sortArr.length - 1 - i];
				sortArr[sortArr.length - 1 - i] = sortArr[i];
				sortArr[i] = temp;
			}

			for (int i = lastAsc + 1; i < startArr2.length; i++) {
				startArr2[i] = sortArr[i - lastAsc - 1];
			}
		}

		private int[] getCopyArr(int start, int[] startArr2) {

			int[] ret = new int[startArr2.length - start];
			for (int i = start; i < startArr2.length; i++) {
				ret[i - start] = startArr2[i];
			}

			return ret;
		}

		private int findLastAsc(int[] startArr2) {
			for (int i = startArr2.length - 1; i > 0; i--) {
				if (startArr2[i] > startArr2[i - 1]) {
					return i - 1;
				}
			}
			return -1;
		}

		public long getIntVal(int[] arr) {
			long sum = arr[0];

			for (int i = 1; i < arr.length; i++) {
				sum = sum * 10 + arr[i];
			}

			return sum;

		}
	}

}


whuawell
关注
专栏目录
projecteuler.net:我对 Project Euler 问题的一些解决方案
07-20
在这个"projecteuler.net:我对 Project Euler 问题的一些解决方案"中，我们可以预见到包含的是作者对 Project Euler 题目的Java实现。 在项目中，"projecteuler.net-master"很可能是一个GitHub仓库的名字，通常这样...
project-euler:我对projecteuler.net上问题的解决方案
04-13
在这个压缩包“project-euler-master”中，很显然包含了作者对Project Euler问题的Python解决方案。 在Python编程语言中解决Project Euler问题，我们可以学习到许多关键的编程概念和技术。以下是一些可能涵盖的知识...
Project Euler problem 61
水
09-29 1143
题意很明了。 然后我大概的做法就是暴搜了 先把每个几边形数中四位数的处理出来。 然后我就DFS回溯着找就行了。 比较简单吧。 #include #include #include #include #include #include using namespace std; vectorg[7], v[7][10000]; int vis[7]; void
Project Euler Problem 61 (C++和Python)
jiafengfu的CSDN博客
12-27 261
Problem 61 : Cyclical figurate numbers Triangle, square, pentagonal, hexagonal, heptagonal, and octagonal numbers are all figurate (polygonal) numbers and are generated by the following formulae: Tri...
Euler61
Ivan_zcy的博客
01-01 226
三角形数、正方形数、五边形数、六边形数、七边形数和八边形数统称为多边形数。它们分别由如下的公式给出： 三角形数 P3,n=n(n+1)/2 1, 3, 6, 10, 15, … 正方形数 P4,n=n2 1, 4, 9, 16, 25, … 五边形数 P5,n=n(3n−1)/2 1, 5, 12, 22, 35, … 六边形数 P6,n=n(2n−1) 1, 6...
有关projecteuler题库621题的lisp解答，萌新求围观。
qq_42763173的博客
07-23 230
projecteuler题库 https://projecteuler.net/problem=621 https://pastebin.ubuntu.com/p/w2G5bwbJMR/ 设T(n)是序号n的三角数 那么所计算的数W就是T(n1)+T(n2)+T(n3)   先不管顺序  设(n1 , n2, n3)是从大到小排列 则有T(n1max)=(W/3)，T(n2max)=((W-...
EularProject 61：Cyclical figurate numbers
掉下个小石头
10-17 450
Andrew Zhang Sep 4, 2017Triangle, square, pentagonal, hexagonal, heptagonal, and octagonal numbers are all figurate (polygonal) numbers and are generated by the following formulae:Triangle P3,
Project Euler Problem 38
wxinbeings的博客
06-02 138
Problem 38Take the number 192 and multiply it by each of 1, 2, and 3:192 × 1 = 192192 × 2 = 384192 × 3 = 576By concatenating each product we get the 1 to 9 pandigital, 192384576. We will call 19238457...
Project Euler Problem 47
wxinbeings的博客
06-27 141
Problem 47The first two consecutive numbers to have two distinct prime factors are:14 = 2 × 715 = 3 × 5The first three consecutive numbers to have three distinct prime factors are:644 = 22 × 7 × 23645...
Project Euler Problem 27
wxinbeings的博客
05-06 255
Problem 27Euler discovered the remarkable quadratic formula:n2 + n + 41It turns out that the formula will produce 40 primes for the consecutive values n = 0 to 39. However, when n = 40, 402 + 40 + 41 ...
Project Euler Problem 43
wxinbeings的博客
06-21 150
Problem 43The number, 1406357289, is a 0 to 9 pandigital number because it is made up of each of the digits 0 to 9 in some order, but it also has a rather interesting sub-string divisibility property....
ProjectEuler:Project Euler 问题的解决方案
06-12
"Project Euler: Project Euler 问题的解决方案"是一个与编程挑战相关的项目，主要集中在使用JavaScript解决数学和计算问题。Project Euler是一个著名的在线平台，它提供了一系列的数学和计算机科学问题，旨在提升...
Project-Euler:ProjectEuler +解决方案
05-15
该软件包包含我针对Euler项目问题​​的解决方案代码。 源代码包括对所涉及数学的详细说明，以证明程序中的逻辑合理。 此代码仅供“参考”。 您需要事先获得书面许可才能执行以下任何操作：逐字重新发布代码，发布...
Project-Euler:projecteuler.net 上问题的解决方案
06-22
这个压缩包“Project-Euler:projecteuler.net 上问题的解决方案”显然是一个包含 JavaScript 语言解答的 Project Euler 问题集合。 JavaScript 是一种广泛使用的解释型编程语言，特别适用于Web开发，但同样适用于...
JSP学生学籍管理系统设计与实现(源代码+论文+开题报告+外文翻译+答辩PPT).zip
09-21
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
省市区数据，完成三级联动，选择地区
09-21
省市区数据，完成三级联动，选择地区
机械原理课程设计网球自动捡球机.doc
最新发布
09-21
机械原理课程设计网球自动捡球机.doc
2024秋招华为笔试题大全-仅供参考具体需要根据实际修改
09-21
2024秋招华为笔试题大全-仅供参考具体需要根据实际修改
借助于Ascend310 AI处理器完成深度学习算法部署任务，
09-21
应用背景为变电站电力巡检，基于YOLO v4算法模型对常见电力巡检目标进行检测，并充分利用Ascend310提供的DVPP等硬件支持能力来完成流媒体的传输、处理等任务，并对系统性能做出一定的优化。.zip深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
寻找大整数的最大质因数：Project Euler Problem 3
在给定的标题"ProJectEulerProblem3"中，这是一个关于编程挑战的问题，源自著名的Project Euler系列，问题3要求找到600851475143这个数字的最大质因数。描述中提到，13195的质因数包括5、7、13和29，这可能是为了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值