PAT A1030 Travel Plan

最新推荐文章于 2021-05-31 20:39:42 发布
最新推荐文章于 2021-05-31 20:39:42 发布
阅读量117 收藏
点赞数
分类专栏： PAT A 文章标签： Dijkstra
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42347617/article/details/98900910
版权

PAT A1030 Travel Plan

在这里插入图片描述

Sample Input:

4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

Sample Output:

0 2 3 3 40
wordmeaning
destinationn. 目的地, 终点

  • 思路1：
    同PAT A1003，Dijkstra()

  • code1:

#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 510;
const int INF = 0xfffffff;

int G[maxn][maxn];
int d[maxn];
int flag[maxn] = {false};
int pre[maxn];	//只存放最优路径 
int N, M, S, E;
int cost[maxn][maxn]; 
int dcost[maxn][maxn];

void Dijkstra(int s){
	fill(d, d+maxn, INF);
	fill(dcost[0], dcost[0]+maxn*maxn, 0);
	d[s] = 0;
	for(int i = 0; i < N; ++i){
		int mid = -1, MIN = INF;
		for(int j = 0; j < N; ++j){
			if(flag[j] == false && d[j] < MIN){
				mid = j;
				MIN = d[j];
			}
		}
		if(mid == -1) return;
		flag[mid] = true;
		for(int k = 0; k < N; ++k){
			if(flag[k] == false && G[mid][k] != INF){
				if(G[mid][k] + d[mid] < d[k]){
					d[k] = G[mid][k] + d[mid];
					dcost[s][k] = dcost[s][mid] + cost[mid][k];
					pre[k] = mid;
				}else if(G[mid][k] + d[mid] == d[k]){
					if(dcost[s][k] > dcost[s][mid] + cost[mid][k]){
						d[k] = G[mid][k] + d[mid];
						dcost[s][k] = dcost[s][mid] + cost[mid][k];
						pre[k] = mid;
					} 
				}
			}
		}
	}
}

int main(){
	scanf("%d %d %d %d", &N, &M, &S, &E);
	fill(G[0], G[0]+maxn*maxn,INF);
	int c1, c2, dis, cos;
	for(int i = 0; i < M; ++i){
		scanf("%d %d %d %d", &c1, &c2, &dis, &cos);
		G[c1][c2] = dis;
		G[c2][c1] = dis;
		cost[c1][c2] = cos;
		cost[c2][c1] = cos;
	}
	Dijkstra(S);
	int e = E;
	vector<int> res;
	while(e != S){
		res.push_back(e);
		e = pre[e];
	}
	res.push_back(S);
	for(int i = res.size()-1; 0 <= i; --i)
		printf("%d ", res[i]);
	printf("%d ", d[E]);
	printf("%d", dcost[S][E]);	
	return 0;
}
  • T2 code:
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100, INF = 0x3fffffff;
int G_len[maxn][maxn], G_cost[maxn][maxn], d[maxn], dc[maxn], pre[maxn];
bool vis[maxn];

void Dijkstra(int start, int destination, int n){
	fill(d, d + maxn, INF);	
	fill(dc, dc + maxn, INF);	
	memset(vis, false, sizeof(vis));
	for(int i = 0; i < n; ++i) pre[i] = i;
	d[start] = 0;
	dc[start] = 0;
	for(int i = 0; i < n; ++i){
		int now = -1, Min = INF;
		for(int j = 0; j < n; ++j){
			if(vis[j] == false && d[j] < Min){
				Min = d[j];
				now = j;
			}
		}
		if(now == -1 || now == destination) return;
		vis[now] = true;
		for(int j = 0; j < n; ++j){
			if(vis[j] == false && G_len[now][j] != INF){
				if(d[now] + G_len[now][j] < d[j]){
					d[j] = d[now] + G_len[now][j];
					dc[j] = dc[now] + G_cost[now][j];
					pre[j] = now;
				}else if(d[now] + G_len[now][j] == d[j] && dc[now] + G_cost[now][j] < dc[j]){
					dc[j] = dc[now] + G_cost[now][j];
					pre[j] = now;				
				}
			}
		}
	}
}
void DFS(int id, int start){
	if(id == start){
		printf("%d ", id);
		return;
	}
	DFS(pre[id], start);
	printf("%d ", id);
}
int main(){
	int n, m, s, e;
	scanf("%d %d %d %d", &n, &m, &s, &e);
	fill(G_len[0], G_len[0] + maxn * maxn, INF);
	fill(G_cost[0], G_cost[0] + maxn * maxn, INF);
	for(int i = 0; i < m; ++i){
		int c1, c2;
		scanf("%d %d", &c1, &c2);
		scanf("%d %d", &G_len[c1][c2], &G_cost[c1][c2]);
		G_len[c2][c1] = G_len[c1][c2];
		G_cost[c2][c1] = G_cost[c1][c2];
	}
	Dijkstra(s, e, n);
	DFS(e, s);
	printf("%d %d", d[e], dc[e]);
	return 0;
}
  • T3 code: 堆优化
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010, INF = 0x3fffffff;
int G[maxn][maxn], cost[maxn][maxn], d[maxn], dc[maxn];
bool vis[maxn];

struct node
{
    int id, d;
    bool operator < (const node & tmp) const { return d > tmp.d; }
};
int pre[maxn];
void Dijkstra(int s, int dest, int n)
{
    fill(d, d + n, INF);
    fill(dc, dc + n, INF);
    d[s] = 0;
    dc[s] = 0;
    priority_queue<node> pq;
    pq.push(node{s, 0});
    while(!pq.empty())
    {
        node now = pq.top();
        pq.pop();
        if(now.id == dest) return;
        if(vis[now.id]) continue;
        vis[now.id] = true;
        for(int i = 0; i < n; ++i)
        {
            if(vis[i] == false && G[now.id][i] != 0)
            {
                if(now.d + G[now.id][i] < d[i])
                {
                    d[i] = now.d + G[now.id][i];
                    dc[i] = dc[now.id] + cost[now.id][i];
                    pre[i] = now.id;
                    pq.push({i, d[i]});
                }else if(now.d + G[now.id][i] == d[i])
                {
                    if(dc[now.id] + cost[now.id][i] < dc[i])
                    {
                        dc[i] = dc[now.id] + cost[now.id][i];
                        pre[i] = now.id;
                        pq.push({i, d[i]});
                    }
                }
            }
        }
    }
}
void PrintPath(int id, int s)
{
    if(id == s)
    {
        printf("%d", id);
        return;
    }
    PrintPath(pre[id], s);
    printf(" %d", id);
}
int main()
{
    int nc, m, s, e;
    scanf("%d %d %d %d", &nc, &m, &s, &e);
    for(int i = 0; i < m; ++i)
    {
        int c1, c2, dis, cos;
        scanf("%d %d %d %d", &c1, &c2, &dis, &cos);
        G[c1][c2] = G[c2][c1] = dis;
        cost[c1][c2] = cost[c2][c1] = cos;
    }
    Dijkstra(s, e, nc);
    PrintPath(e, s);
    printf(" %d %d", d[e], dc[e]);
    return 0;
}
  • TIPS: dcost[]的意义是，起点s到其他各点的最大花费，是一维的，故不需要二维dcost[][],只用dcost[]表示就可以
  • 思路2：
    Dijkstra()+DFS()
  • code2:
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 510;
const int INF = 0xfffffff;

int G[maxn][maxn];
int d[maxn];
int flag[maxn] = {false};
vector<int> pre[maxn];
int N, M, S, E;
int cost[maxn][maxn]; 

void Dijkstra(int s){
	fill(d, d+maxn, INF);
	d[s] = 0;
	for(int i = 0; i < N; ++i){
		int mid = -1, MIN = INF;
		for(int j = 0; j < N; ++j){
			if(flag[j] == false && d[j] < MIN){
				mid = j;
				MIN = d[j];
			}
		}
		if(mid == -1) return;
		flag[mid] = true;
		for(int k = 0; k < N; ++k){
			if(flag[k] == false && G[mid][k] != INF){
				if(G[mid][k] + d[mid] < d[k]){
					d[k] = G[mid][k] + d[mid];
					pre[k].clear();
					pre[k].push_back(mid);
				}else if(G[mid][k] + d[mid] == d[k]){
					pre[k].push_back(mid);
				}
			}
		}
	}
}

int optC = INF;
vector<int> tmp, res;

void DFS(int v){
	if(v == S){
		tmp.push_back(v);
		int tmpC = 0;
		for(int i = tmp.size() - 1; 0 < i; --i){
			int id = tmp[i]; int id_next = tmp[i-1];
			tmpC += cost[id][id_next];
		}
		if(tmpC < optC){
			optC = tmpC;
			res = tmp;
		}
		tmp.pop_back();
		return;
	}
	tmp.push_back(v);
	for(int i = 0; i < pre[v].size(); ++i){
		DFS(pre[v][i]);
	}
	tmp.pop_back();
}

int main(){
	scanf("%d %d %d %d", &N, &M, &S, &E);
	fill(G[0], G[0]+maxn*maxn,INF);
	int c1, c2, dis, cos;
	for(int i = 0; i < M; ++i){
		scanf("%d %d %d %d", &c1, &c2, &dis, &cos);
		G[c1][c2] = dis;
		G[c2][c1] = dis;
		cost[c1][c2] = cos;
		cost[c2][c1] = cos;
	}
	Dijkstra(S);
	DFS(E);
	for(int i = res.size() - 1; 0 <= i; --i)
		printf("%d ", res[i]);
	printf("%d ", d[E]);
	printf("%d", optC);
	return 0;
}
  • T2 code:
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100, INF = 0x3fffffff;
int g_len[maxn][maxn], g_cost[maxn][maxn], d[maxn];
bool vis[maxn];
vector<int> pre[maxn];

void Dijkstra(int start, int end, int n){
	fill(d, d + maxn, INF);
	memset(vis, false, sizeof(vis));
	d[start] = 0;
	for(int i = 0; i < n; ++i){
		int now = -1, Min = INF;
		for(int j = 0; j < n; ++j){
			if(vis[j] == false && d[j] < Min){
				Min = d[j];
				now = j;
			}
		}
		if(now == -1 || now == end) return;
		vis[now] = true;
		for(int j = 0; j < n; ++j){
			if(vis[j] == false && g_len[now][j] != INF){
				if(d[now] + g_len[now][j] < d[j]){
					d[j] = d[now] + g_len[now][j];
					pre[j].clear();
					pre[j].push_back(now);
				}else if(d[now] + g_len[now][j] == d[j]){
					pre[j].push_back(now);
				}
			}
		}
	}
}

vector<int> tmp, ans;
int min_cost = INF;
void DFS(int id, int start){
	tmp.push_back(id);
	if(id == start){
		int tmp_cost = 0;
		for(int i = tmp.size()-1; i > 0; --i){
			int tnow = tmp[i], tnext = tmp[i-1];
			tmp_cost += g_cost[tnow][tnext];
		}
		if(tmp_cost < min_cost){
			min_cost = tmp_cost;
			ans = tmp;
		}
		return;
	}
	for(int i = 0; i < pre[id].size(); ++i){
		int next = pre[id][i];
		DFS(next, start);
		tmp.pop_back();
	}
}

int main(){
	int n, m, s, e;
	scanf("%d %d %d %d", &n, &m, &s, &e);
	fill(g_len[0], g_len[0] + maxn * maxn, INF);
	fill(g_cost[0], g_cost[0] + maxn * maxn, INF);
	for(int i = 0; i < m; ++i){
		int c1, c2;
		scanf("%d %d", &c1, &c2);
		scanf("%d %d", &g_len[c1][c2], &g_cost[c1][c2]);
		g_len[c2][c1] = g_len[c1][c2];
		g_cost[c2][c1] = g_cost[c1][c2];
	}	
	Dijkstra(s, e, n);
	DFS(e, s);
	for(int i = ans.size()-1; i >= 0; --i) printf("%d ", ans[i]);
	printf("%d %d", d[e], min_cost);
	return 0;
}
  • T3 code:
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010, INF = 0x3fffffff;
int G[maxn][maxn], cost[maxn][maxn], d[maxn];
bool vis[maxn];

struct node
{
    int id, d;
    bool operator < (const node & tmp) const { return d > tmp.d; }
};
vector<int> pre[maxn];
void Dijkstra(int s, int dest, int n)
{
    fill(d, d + n, INF);
    d[s] = 0;
    priority_queue<node> pq;
    pq.push(node{s, 0});
    while(!pq.empty())
    {
        node now = pq.top();
        pq.pop();
        if(now.id == dest) return;
        if(vis[now.id]) continue;
        vis[now.id] = true;
        for(int i = 0; i < n; ++i)
        {
            if(vis[i] == false && G[now.id][i] != 0)
            {
                if(now.d + G[now.id][i] < d[i])
                {
                    d[i] = now.d + G[now.id][i];
                    pre[i].clear();
                    pre[i].push_back(now.id);
                    pq.push({i, d[i]});
                }else if(now.d + G[now.id][i] == d[i])
                {
                    pre[i].push_back(now.id);
                    pq.push({i, d[i]});
                }
            }
        }
    }
}
vector<int> tmp, ans;
void DFS(int id, int s, int & min_cost)
{
    tmp.push_back(id);
    if(id == s)
    {
        int sum_cost = 0, pre = tmp[0];
        for(int i = 1; i < tmp.size(); ++i)
        {
            int now = tmp[i];
            sum_cost += cost[pre][now];
            pre = now;
        }
        if(sum_cost < min_cost)
        {
            min_cost = sum_cost;
            ans = tmp;
        }
        tmp.pop_back();
        return; //!!! WRONG:return 回上一层了，这层的id没pop出去
    }
    for(int i = 0; i < pre[id].size(); ++i)
    {
        int nex = pre[id][i];
        DFS(nex, s, min_cost);
    }
    tmp.pop_back();
}
int main()
{
    int nc, m, s, e;
    scanf("%d %d %d %d", &nc, &m, &s, &e);
    for(int i = 0; i < m; ++i)
    {
        int c1, c2, dis, cos;
        scanf("%d %d %d %d", &c1, &c2, &dis, &cos);
        G[c1][c2] = G[c2][c1] = dis;
        cost[c1][c2] = cost[c2][c1] = cos;
    }
    Dijkstra(s, e, nc);
    int Min = INF;
    DFS(e, s, Min);
    for(int i = ans.size()-1; i >= 0; --i)
    {
        printf("%d ", ans[i]);
    }
    printf("%d %d", d[e], Min);
    return 0;
}
  • BF
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510, INF = 0x3fffffff;
int d[maxn], dc[maxn];
struct node
{
    int nex, dis, cost;
};
vector<node> G[maxn];

int pre[maxn];
bool BF(int start, int n)
{
    fill(d, d + maxn, INF);
    fill(dc, dc + maxn, INF);
    d[start] = 0; dc[start] = 0;
    for(int i = 0; i < n-1; ++i)
    {
        bool isUpdate = false;
        for(int now = 0; now < n; ++now)
        {
            for(int j = 0; j < G[now].size(); ++j)
            {
                int nex = G[now][j].nex;
                int dis = G[now][j].dis;
                int cost = G[now][j].cost;
                if(d[now] + dis < d[nex])
                {
                    d[nex] = d[now] + dis;
                    dc[nex] = dc[now] + cost;
                    pre[nex] = now;
                    isUpdate = true;
                }else if(d[now] + dis == d[nex] && dc[now] + cost < dc[nex])
                {
                    dc[nex] = dc[now] + cost;
                    pre[nex] = now;
                    isUpdate = true;
                }
            }
        }
        if(!isUpdate) return true;
    }
    for(int now = 0; now < n; ++now)
    {
        for(int j = 0; j < G[now].size(); ++j)
        {
            int nex = G[now][j].nex;
            int dis = G[now][j].dis;
            int cost = G[now][j].cost;
            if(d[now] + dis < d[nex])
            {
                return false;
            }
        }
    }
    return true;
}
void Print(int id, int s)
{
    if(id == s)
    {
        printf("%d", id);
        return;
    }
    Print(pre[id], s);
    printf(" %d", id);
}
int main()
{
    int n, m, s, e;
    scanf("%d %d %d %d", &n, &m, &s, &e);
    for(int i = 0; i < m; ++i)
    {
        int v1, v2, len, cost;
        scanf("%d %d %d %d", &v1, &v2, &len, &cost);
        G[v1].push_back(node{v2, len, cost});
        G[v2].push_back(node{v1, len, cost});
    }
    BF(s, n);
    Print(e, s);
    printf(" %d %d", d[e], dc[e]);
    return 0;
}
  • SPFA:
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510, INF = 0x3fffffff;
int d[maxn], dc[maxn];
struct node
{
    int nex, dis, cost;
};
vector<node> G[maxn];

int pre[maxn], cnt_inq[maxn];
bool inq[maxn];
bool SPFA(int start, int n)
{
    fill(d, d + maxn, INF);
    fill(dc, dc + maxn, INF);
    d[start] = 0; dc[start] = 0;
    queue<int> q;
    q.push(start);
    inq[start] = true;
    cnt_inq[start]++;
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        inq[now] = false;
        for(int i = 0; i < G[now].size(); ++i)
        {
            int nex = G[now][i].nex;
            int dis = G[now][i].dis;
            int cost = G[now][i].cost;
            if(d[now] + dis < d[nex])
            {
                d[nex] = d[now] + dis;
                dc[nex] = dc[now] + cost;
                pre[nex] = now;
                if(inq[nex] == false)
                {
                    q.push(nex);
                    inq[nex] = true;
                    cnt_inq[nex]++;
                    if(cnt_inq[nex] >= n) return true;
                }
            }else if(d[now] + dis == d[nex] && dc[now] + cost < dc[nex])
            {
                dc[nex] = dc[now] + cost;
                pre[nex] = now;
                if(inq[nex] == false)
                {
                    q.push(nex);
                    inq[nex] = true;
                    cnt_inq[nex]++;
                    if(cnt_inq[nex] >= n) return true;
                }
            }
        }
    }
    return true;
}

void Print(int id, int s)
{
    if(id == s)
    {
        printf("%d", id);
        return;
    }
    Print(pre[id], s);
    printf(" %d", id);
}
int main()
{
    int n, m, s, e;
    scanf("%d %d %d %d", &n, &m, &s, &e);
    for(int i = 0; i < m; ++i)
    {
        int v1, v2, len, cost;
        scanf("%d %d %d %d", &v1, &v2, &len, &cost);
        G[v1].push_back(node{v2, len, cost});
        G[v2].push_back(node{v1, len, cost});
    }
    SPFA(s, n);
    Print(e, s);
    printf(" %d %d", d[e], dc[e]);
    return 0;
}
fffffffff_jj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PAT乙级1001~1030.rar
07-30
《PAT乙级编程题解1001~1030》 在计算机科学与信息技术领域，编程竞赛和练习是提升编程技能、锻炼算法思维的重要途径。PAT（Programming Ability Test）是中国计算机学会主办的一项全国性计算机编程能力考试，旨在...
PAT_Alevel:http
05-09
浙江大学的PAT（Programming Ability Test）是一项旨在考察计算机编程能力的考试，其中A Level部分主要面向非计算机专业的学生，涉及基础的算法和数据结构。本资料集"PAT_Alevel:http"是针对这一考试的一系列算法...
A1030 Travel Plan
qq_35785913的博客
03-14 240
#include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;vector&gt; #include&lt;algorithm&gt; using namespace std; const int maxv=510; const int INF=1000000000; int n,m,st,ed,G[maxv][maxv],cost[max...
1030. Travel Plan (30)
weixin_30367873的博客
08-25 87
原题如下： A traveler's map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide th...
Travel Plan
丁一的博客
09-03 222
#include&lt;iostream&gt; #include&lt;cstring&gt; using namespace std; const int inf=1000000000; int N,M,S,D,e[510][510],cost[510][510],d[510],c[510],pre[510]; bool vis[510]; void dij(int start){ mem...
Travel Plan(PAT)
小黯
07-13 224
1
【PAT A1030】 Travel Plan
ikechan的博客
08-17 358
1030 Travel Plan （30 分） 时间限制: 400ms 内存限制: 64MB 代码长度限制: 16KB A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supp...
pat甲级单词pat甲级单词pat甲级单词
06-12
pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词...
PAT乙级1022 D进制的A+B
06-06
PAT乙级1022源代码 codeblocks 输入两个非负10进制整数A和B()，输出A+B的D (1 )进制数。
C#例子代码 A0102_Path
06-17
C#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 ...
1030 Travel Plan (30)
ysq96的博客
07-06 638
A traveler's map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path b...
1030 Travel Plan
Cooocktail的博客
02-19 369
1030 Travel Plan （30 分） A traveler's map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to d...
PTA-1030 Travel Pla(使用堆优化的dijkstra算法)
qq_45929428的博客
05-31 145
PTA-1030 Travel Plan (30 分) A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting cit.
PAT A1030 Travel Plan【SPFA+输出路径】
qq_37509216的博客
08-08 133
本题是一道最短路径水题，和普通最短路径不一样的是，本题不仅要考虑路径长度，还要考虑路径上的花费。除此之外，还要输出路径。考虑路径上的花费比较简单，直接在SPFA的时候添加判断即可，输出路径则在存边的时候开两个数组，一个专门存前驱，一个专门存后继。在最后，倒序遍历，就可以找到唯一的一条最短路径。 #include <iostream> #include<vector> #include<cstdio> #include<algorithm> #include&l
【PAT甲级】1030 Travel Plan (30 分)（SPFA,DFS）
weixin_30919571的博客
09-11 125
题意： 输入N,M,S,D（N,M<=500,0<S,D<N）,接下来M行输入一条边的起点，终点，通过时间和通过花费。求花费最小的最短路，输入这条路径包含起点终点，通过时间和通过花费。 trick： 找了半小时bug终于发现是给dis数组赋初值时范围是1~N，这道题点是从0~N-1的，故初次只通过了第0组数据，初始化改一下边界即可AC。 代码： #define...
PAT 1030 Travel Plan（30 分）
Hickey_Chen的博客
08-26 267
A traveler's map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path b...
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值