数据结构——浙大版中国大学mooc(week7)

MOOC 数据结构 07-图6 旅游规划 有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。 输入格式: 输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:城市1、城市2、高速公路长度、收费额 阅读详情

课程给出代码

C语言:邻接表存储 - 无权图的单源最短路算法

/* 邻接表存储 - 无权图的单源最短路算法 */
 
/* dist[]和path[]全部初始化为-1 */
void Unweighted ( LGraph Graph, int dist[], int path[], Vertex S )
{
    Queue Q;
    Vertex V;
    PtrToAdjVNode W;
     
    Q = CreateQueue( Graph->Nv ); /* 创建空队列, MaxSize为外部定义的常数 */
    dist[S] = 0; /* 初始化源点 */
    AddQ (Q, S);
 
    while( !IsEmpty(Q) ){
        V = DeleteQ(Q);
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */
            if ( dist[W->AdjV]==-1 ) { /* 若W->AdjV未被访问过 */
                dist[W->AdjV] = dist[V]+1; /* W->AdjV到S的距离更新 */
                path[W->AdjV] = V; /* 将V记录在S到W->AdjV的路径上 */
                AddQ(Q, W->AdjV);
            }
    } /* while结束*/
}

C语言:邻接矩阵存储 - 有权图的单源最短路算法

/* 邻接矩阵存储 - 有权图的单源最短路算法 */
 
Vertex FindMinDist( MGraph Graph, int dist[], int collected[] )
{ /* 返回未被收录顶点中dist最小者 */
    Vertex MinV, V;
    int MinDist = INFINITY;
 
    for (V=0; V<Graph->Nv; V++) {
        if ( collected[V]==false && dist[V]<MinDist) {
            /* 若V未被收录,且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回对应的顶点下标 */
    else return ERROR;  /* 若这样的顶点不存在,返回错误标记 */
}
 
bool Dijkstra( MGraph Graph, int dist[], int path[], Vertex S )
{
    int collected[MaxVertexNum];
    Vertex V, W;
 
    /* 初始化:此处默认邻接矩阵中不存在的边用INFINITY表示 */
    for ( V=0; V<Graph->Nv; V++ ) {
        dist[V] = Graph->G[S][V];
        if ( dist[V]<INFINITY )
            path[V] = S;
        else
            path[V] = -1;
        collected[V] = false;
    }
    /* 先将起点收入集合 */
    dist[S] = 0;
    collected[S] = true;
 
    while (1) {
        /* V = 未被收录顶点中dist最小者 */
        V = FindMinDist( Graph, dist, collected );
        if ( V==ERROR ) /* 若这样的V不存在 */
            break;      /* 算法结束 */
        collected[V] = true;  /* 收录V */
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            /* 若W是V的邻接点并且未被收录 */
            if ( collected[W]==false && Graph->G[V][W]<INFINITY ) {
                if ( Graph->G[V][W]<0 ) /* 若有负边 */
                    return false; /* 不能正确解决,返回错误标记 */
                /* 若收录V使得dist[W]变小 */
                if ( dist[V]+Graph->G[V][W] < dist[W] ) {
                    dist[W] = dist[V]+Graph->G[V][W]; /* 更新dist[W] */
                    path[W] = V; /* 更新S到W的路径 */
                }
            }
    } /* while结束*/
    return true; /* 算法执行完毕,返回正确标记 */
}

C语言:邻接矩阵存储 - 多源最短路算法

/* 邻接矩阵存储 - 多源最短路算法 */
 
bool Floyd( MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum] )
{
    Vertex i, j, k;
 
    /* 初始化 */
    for ( i=0; i<Graph->Nv; i++ )
        for( j=0; j<Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
            path[i][j] = -1;
        }
 
    for( k=0; k<Graph->Nv; k++ )
        for( i=0; i<Graph->Nv; i++ )
            for( j=0; j<Graph->Nv; j++ )
                if( D[i][k] + D[k][j] < D[i][j] ) {
                    D[i][j] = D[i][k] + D[k][j];
                    if ( i==j && D[i][j]<0 ) /* 若发现负值圈 */
                        return false; /* 不能正确解决,返回错误标记 */
                    path[i][j] = k;
                }
    return true; /* 算法执行完毕,返回正确标记 */
}

07-图4 哈利·波特的考试 (25 分)

哈利·波特要考试了,他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha,将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念,例如ahah可以将老鼠变成猫。另外,如果想把猫变成鱼,可以通过念一个直接魔咒lalala,也可以将猫变老鼠、老鼠变鱼的魔咒连起来念:hahahehe。
现在哈利·波特的手里有一本教材,里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场,要考察他把这只动物变成任意一只指定动物的本事。于是他来问你:带什么动物去可以让最难变的那种动物(即该动物变为哈利·波特自己带去的动物所需要的魔咒最长)需要的魔咒最短?例如:如果只有猫、鼠、鱼,则显然哈利·波特应该带鼠去,因为鼠变成另外两种动物都只需要念4个字符;而如果带猫去,则至少需要念6个字符才能把猫变成鱼;同理,带鱼去也不是最好的选择。
输入格式:
输入说明:输入第1行给出两个正整数N (≤100)和M,其中N是考试涉及的动物总数,M是用于直接变形的魔咒条数。为简单起见,我们将动物按1~N编号。随后M行,每行给出了3个正整数,分别是两种动物的编号、以及它们之间变形需要的魔咒的长度(≤100),数字之间用空格分隔。
输出格式:
输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度,中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的,则输出0。如果有若干只动物都可以备选,则输出编号最小的那只。

#include<stdio.h>
#include<stdbool.h>

#define MaxVertexNum 100 /*设置最大顶点数为100*/
#define INF 99999        /*定义无穷数值为99999*/
typedef int Vertex;      /*顶点下标表示顶点*/
typedef int WeightType;  /*边的权值*/
/*typedef char DataType;   /*顶点存储的数据类型*/
/*定义边*/
typedef struct ENode *PtrToENode;
struct ENode{
	Vertex V1,V2;        /*有向边<V1,V2>*/
	WeightType Weight;   /*权值*/
};
typedef PtrToENode Edge;
/*定义图顶点*/
typedef struct GNode *PtrToGNode;
struct GNode{
	int Nv;              /*顶点数*/
	int Ne;              /*边数*/
	WeightType G[MaxVertexNum][MaxVertexNum];
	/*DataType Data[MaxVertexNum];/*顶点数据*/
};
typedef PtrToGNode MGraph;/*以邻接矩阵存储的图类型*/

MGraph CreatGraph(int VertexNum){
	Vertex V, M;
	MGraph Graph;
	Graph=(MGraph)malloc(sizeof(struct GNode));
	Graph->Nv=VertexNum;
	Graph->Ne=0;
	for(V=0;V<Graph->Nv;V++)
		for(M=0;M<Graph->Nv;M++)
				Graph->G[V][M]=INF;
	return Graph;
}

void InsertEdge(MGraph Graph,Edge E){
	Graph->G[E->V1][E->V2]=E->Weight;
	Graph->G[E->V2][E->V1]=E->Weight;	/*无向图*/
}

MGraph BuildGraph(){
	MGraph Graph;
	Edge E;
	/*Vertex  V*/
	int Nv, i;
	scanf("%d",&Nv);        /*读入顶点个数*/
	Graph=CreatGraph(Nv);   /*创建only顶点无边的图*/
	scanf("%d",&(Graph->Ne));
	if(Graph->Ne!=0){
		E=(Edge)malloc(sizeof(struct ENode));/*建立边节点*/
		for(i=0;i<Graph->Ne;i++){
			scanf("%d %d %d",&E->V1,&E->V2,&E->Weight);
			E->V1--;E->V2--;/*起始节点的序号从0开始*/
			InsertEdge(Graph,E);
		}
	}
	/*for(每个顶点Nv)读入数值*/
	return Graph; 
}

WeightType FindMaxDist(WeightType D[][MaxVertexNum],Vertex i, int N){
	WeightType MaxDist;
	Vertex j;
	MaxDist=0;
	for(j=0;j<N;j++)
		if(i!=j&&D[i][j]>MaxDist)
			MaxDist=D[i][j];
	return MaxDist;
}

void Floyd( MGraph Graph, WeightType D[][MaxVertexNum]/*, Vertex path[][MaxVertexNum] */)
{
    Vertex i, j, k;
    /* 初始化 */
    for ( i=0; i<Graph->Nv; i++ )
        for( j=0; j<Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
            /*path[i][j] = -1;*/
        }
    for( k=0; k<Graph->Nv; k++ )
        for( i=0; i<Graph->Nv; i++ )
            for( j=0; j<Graph->Nv; j++ )
                if( D[i][k] + D[k][j] < D[i][j] ) {
                    D[i][j] = D[i][k] + D[k][j];
                    /*if ( i==j && D[i][j]<0 ) /* 若发现负值圈 
                        return false; /* 不能正确解决,返回错误标记 
                     path[i][j] = k;*/
                }
    /*return true; /* 算法执行完毕,返回正确标记 */
}

void FindAnimal(MGraph Graph){
	WeightType D[MaxVertexNum][MaxVertexNum],MaxDist,MinDist;
	Vertex Animal, i;
	Floyd(Graph,D);
	MinDist=INF;
	for(i=0;i<Graph->Nv;i++){
		MaxDist=FindMaxDist(D,i,Graph->Nv);
		if(MaxDist==INF){
			printf("0\n");
			return;
		}
		if(MinDist>MaxDist){/*找到最长距离更小的动物,跟新值,记录编号*/
			MinDist=MaxDist;
			Animal=i+1;
		}
	}
	printf("%d %d\n",Animal,MinDist);
}

int main(){
	MGraph G=BuildGraph();
	FindAnimal(G);
	return 0;
}

07-图5 Saving James Bond - Hard Version (30 分)

This time let us consider the situation in the movie “Live and Let Die” in which James Bond, the world’s most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape – he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head… Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).
Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him a shortest path to reach one of the banks. The length of a path is the number of jumps that James has to make.
Input Specification:
Each input file contains one test case. Each case starts with a line containing two positive integers N (≤100), the number of crocodiles, and D, the maximum distance that James could jump. Then N lines follow, each containing the (x,y) location of a crocodile. Note that no two crocodiles are staying at the same position.
Output Specification:
For each test case, if James can escape, output in one line the minimum number of jumps he must make. Then starting from the next line, output the position (x,y) of each crocodile on the path, each pair in one line, from the island to the bank. If it is impossible for James to escape that way, simply give him 0 as the number of jumps. If there are many shortest paths, just output the one with the minimum first jump, which is guaranteed to be unique.
没时间做了,代码来源:https://www.cnblogs.com/minesweeper/p/5954733.html

#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "algorithm"
using namespace std;
int n, m;
#define MINLEN 42.5
struct Pointer {
    int x;
    int y;
}point[101];
bool answer = false; /* 记录007能否安全逃生~~ */
bool visited[101] = { false }; /* 判断当前点是否被访问过 */
int path[101] = {-1}; /* 记录跳跃过程中踩过的鳄鱼 */
bool isSave(int x) { /* 判断从当前点能否跳到岸上 */
    if ((point[x].x - m <= -50) || (point[x].x + m >= 50) || (point[x].y - m <= -50) || (point[x].y + m >= 50))
        return true;
    return false;
}

bool jump(int x, int y) { /* 判断2个点距离是否在跳跃能力内 */
    int p1 = pow(point[x].x - point[y].x, 2);
    int p2 = pow(point[x].y - point[y].y, 2);
    int r = m * m;
    if (p1 + p2 <= r)
        return true;
    return false;
}

int firstJump(int x) {  /* 当007处于孤岛时 第一次可以选择跳的鳄鱼 因为第一次判断能否跳跃的计算方法与后面dfs不相同 所以要单独写 */
    int p1 = pow(point[x].x, 2);
    int p2 = pow(point[x].y, 2);
    int r = (m + 7.5) * (m + 7.5);
    if (p1 + p2 <= r) {
        return p1+p2;
    }
    return 0;
}
bool cmp(int a,int b) {
    return firstJump(a) < firstJump(b);
}
void bfs() { /* 用bfs来判断最少要踩几个小鳄鱼才能上岸 */
    int b[101];
    queue<int>q; 
    /* 将第一步能踩到的鳄鱼按距离从小到大的顺序进队列~ 因为输出结果要保证在踩的鳄鱼数量相等的情况下 输出第一步距离最短的~~*/
    for (int i = 0; i < n; i++) {
        b[i] = i;
    }
    sort(b, b + n, cmp); /* 按照第一步的距离排序~~~ */
    int last;
    for (int i = 0; i < n; i++) {
        if (firstJump(b[i])) { /* 能跳上去! */
            q.push(b[i]);
            visited[b[i]] = true; /* 指向当前层数最后一个数~ */
            last = b[i];
        }
    }
    int step = 2;  /* 记录最少要跳跃的次数 */
    int tail; 
    while (!q.empty()) {
        int p = q.front();
        q.pop();
        if (isSave(p)) {
            int k = 1;
            stack<int> s;
            cout << step << endl;
            while (k < step) {
                //cout << point[p].x << " " << point[p].y << endl;
                s.push(p);
                p = path[p];
                k++;
            }
            while (!s.empty()) {
                p = s.top();
                s.pop();
                cout << point[p].x << " " << point[p].y << endl;
            }
            return;
        }
        for (int i = 0; i < n; i++) {
            if (!visited[i] && jump(p, i)) { /* 没踩过并且能跳到 */
                q.push(i);
                path[i] = p; /* 记得当前进队节点的父节点~ */
                visited[i] = true;
                tail = i; /* 指向下一层的最后一个元素 */
            }
        }
        if (last == p) { /* 即将进入下一层~ */
            step += 1;
            last = tail;
        }
    }
    if (q.empty()) { /* 如果队列为空  说明没跳出去啊~ */
        cout << "0" << endl;
    }
}
int main() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> point[i].x >> point[i].y;
    }
    if (m >= MINLEN) { /* 可以直接从孤岛上提到岸上 直接输出 */
        cout << "1" << endl;
        return 0;
    }
    bfs();
    return 0;
}

07-图6 旅游规划 (25 分)

有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。
输入格式:
输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:城市1、城市2、高速公路长度、收费额,中间用空格分开,数字均为整数且不超过500。输入保证解的存在。
输出格式:
在一行里输出路径的长度和收费总额,数字间以空格分隔,输出结尾不能有多余空格。
没时间做了,代码来源:https://blog.youkuaiyun.com/qq_37618760/article/details/83386015

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#define INF 10000000
using namespace std;
const int Max=500;
int Map[Max+5][Max+5];
int Cost[Max+5][Max+5];
int dis[Max+5],MCost[Max+5];
bool vis[Max+5]={false};
int Min;
void Dijkstra(int v0,int v,int d){
 
     dis[v0]=0; vis[v0]=true;
    for(int i=0;i<v;i++){
        Min=INF;
        for(int k=0;k<v;k++){
            if(!vis[k]){
                if(dis[k]<Min){
                    Min=dis[k];
                    v0=k;
                }
            }
        }
        vis[v0]=true;
        for(int k=0;k<v;k++){
            if(!vis[k]&&Min+Map[v0][k]<dis[k]){
                dis[k]=Min+Map[v0][k];
                MCost[k]=MCost[v0]+Cost[v0][k];
            }
            else if(!vis[k]&&Min+Map[v0][k]==dis[k]&&MCost[k]>MCost[v0]+Cost[v0][k]){
                MCost[k]=MCost[v0]+Cost[v0][k];            }
        }
    }
}
int main(){
    int v,e,s,d;
    scanf("%d %d %d %d",&v,&e,&s,&d);
    for(int i=0;i<v;i++)
    for(int j=0;j<v;j++){
        Map[i][j]=Map[j][i]=INF;
        Cost[i][j]=Cost[j][i]=INF;
        //设置为双向连通,并初始化为最大值
    }
    for(int i=0;i<e;i++){
        int a,b,c,d;
        cin>>a>>b>>c>>d;
        Map[a][b]=Map[b][a]=c;
        Cost[a][b]=Cost[b][a]=d;
 
    }
    for(int i=0;i<v;i++){
        dis[i]=Map[i][s];//Map[i][s]为点i到起始点的距离
        MCost[i]=Cost[i][s];
    }
    Dijkstra(s,v,d);
    cout<<dis[d]<<" "<<MCost[d]<<endl;
    return 0;
}
7-3 旅游规划 (25 分)(C语言实现) 有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。 输入格式: 输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:城市1、城市2、高速公路长度、收费额,中 阅读详情

相关推荐

TTS(level 2)

紧急救援(2001)带领你的救援队尽快赶往事发地,同时,一路上召集尽可能多的救援队。输入格式:输入第一行给出4个正整数N、M、S、D,其中N(2&lt;=N&lt;=500)是城市的个数,顺便假设城市的编号为0~(N-1);M是快速道路的条数;S是出发地的城市编号;D是目的地的城市编号。第二行给出N个正整数,其中第i个数是第i个城市的救援队的数目,数字间以空格分隔。随后的M行中,每行给出一条快速道...

Lynne的博客 386

PTA L2-001紧急救援(Dijkstra算法应用)

L2-001 紧急救援 (25分) 作为一个城市的应急救援队伍的负责人,你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候,你的任务是带领你的救援队尽快赶往事发地,同时,一路上召集尽可能多的救援队。 输入格式: 输入第一行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0 ~ (N−1);M是快速道路的条数;S是出发地的城市编号;D是目的地

不导翁的博客 3417

数据结构——浙大版中国大学mooc(week10)

排序(下)课程给出代码10-排序4 统计工龄 (20 分)10-排序5 PAT Judge (25 分)10-排序6 Sort with Swap(0, i) (25 分) 课程给出代码 C语言:快速排序 /* 快速排序 - 直接调用库函数 */ #include <stdlib.h> /*---------------简单整数排序--------------------*/ ...

CodingW的博客 318

C语言:L2-001 紧急救援 (25 分) — Dijkstra

文章目录一、题目二、方法11、相关知识点(1)图论(2)迪杰斯特拉算法(Dijkstra):①概念②图解③代码2、思路(1)输入(2)Dijkstra(3)输出3、代码 一、题目 作为一个城市的应急救援队伍的负责人,你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候,你的任务是带领你的救援队尽快赶往事发地,同时,一路上召集尽可能多的救援队。 输入格式: 输入第一行给出4个正

WZRbeliever的博客 4623

【科研学习】Demo3D2015安装包以及图文安装步骤

安装包 点击下图的.exe文件,安装 不需要解压,打开注册机 如下图: 点击上图的.exe文件,出现下图 先点击 patch 打开安装目录下的Demo3D.licensing.dll文件,然后点击Generate,生成dvt-license文件,保存即可 打开安装完成的Demo3D 2015(64-bit),一般破解没完成的,会出现一个request a license 的问题,点击find license 的那一行 点击后找到自己Generate,生成dvt

KaelCui的博客 1万+

嵌入式开发中Tab与空格混用的危害与统一规范实践

在软件工程中,代码格式一致性是保障可读性与团队协作效率的基础。从原理上看,制表符(Tab)与空格(Space)在存储与显示机制上存在本质差异:Tab是控制字符,其显示宽度取决于编辑器设置;空格则是固定宽度的字符。这种差异导致混用时会引发代码对齐错乱、版本控制冲突及跨平台兼容性问题,严重影响工程的可维护性。尤其在嵌入式开发领域,资源受限环境与高可靠性要求使得统一的编码规范更为关键。通过配置编辑器、集成clang-format等自动化工具,可以强制实现缩进风格的一致性,从而提升代码质量与团队协作效率。本文聚焦于

weixin_42545636的博客 278

数据结构——浙大版中国大学mooc(week5)

树(下)课程给出代码05-树7 堆中的路径 (25 分)05-树8 File Transfer (25 分)05-树9 Huffman Codes (30 分) 课程给出代码 C语言描述:堆的描述和操作 typedef struct HNode *Heap; /* 堆的类型定义 */ struct HNode { ElementType *Data; /* 存储元素的数组 */ i...

CodingW的博客 393

人工智能AI在软件测试和质量效能中的实际应用

人工智能在软件测试中应用,介绍chatGPT在测试中的应用,还有多个AI驱动的测试工具。

lindafang72的博客 1万+

数据结构——浙大版中国大学mooc(week8)

图(下)课程给出代码08-图7 公路村村通 (30 分)08-图8 How Long Does It Take (25 分)08-图9 关键活动 (30 分) 课程给出代码 C语言:邻接矩阵存储 - Prim最小生成树算法 /* 邻接矩阵存储 - Prim最小生成树算法 */ Vertex FindMinDist( MGraph Graph, WeightType dist[] ) { /* ...

CodingW的博客 365

【抖音滑动验证码风控分析】

文章摘要:通过对比正常响应与验证码风控响应的头部信息,发现两者存在显著差异。正常响应返回JSON格式数据(Content-Type: application/json)并采用分块传输(Transfer-Encoding: chunked),而风控响应仅返回空文本(Content-Type: text/plain,Content-Length: 0),并通过X-Vc-Bdturing-Parameters等特殊头字段传递风控信息。这些差异主要体现在内容类型、数据传输方式和风控标识参数上,为风控识别提供了关键特

qq_44990881的博客 1104

用废旧汽车电池DIY家用UPS:手把手教你低成本搭建Wi-Fi不断电系统

本文详细介绍了如何利用废旧汽车电池DIY低成本家用UPS系统,确保Wi-Fi设备在断电时持续供电。通过精选材料、电路搭建和安全防护,实现高效稳定的电源转换与智能切换,成本仅为市售UPS的三分之一。特别适合家庭办公和远程工作者提升网络供电可靠性。

weixin_29200485的博客 468

数据结构——浙大版中国大学mooc(week6)

图(上)课程给出代码06-图1 列出连通集 (25 分)06-图2 Saving James Bond - Easy Version (25 分)06-图3 六度空间 (30 分) 课程给出代码 C语言:图的邻接矩阵实现建立 /* 图的邻接矩阵表示法 */ #define MaxVertexNum 100 /* 最大顶点数设为100 */ #define INFINITY 65535 ...

CodingW的博客 365

STM32开发实战:从嵌入式系统到硬件控制 | 你必须得会

🏆本文收录于「编程与技术实战」专栏,此专栏涵盖了C/C++编程、人工智能、数据结构、机器学习等技术领域的内容,助你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!

**My Coding Family** 1048

数据结构——浙大版中国大学mooc(week2)

线性表02-线性结构1 两个有序链表序列的合并 (15 分)02-线性结构2 一元多项式的乘法与加法运算 (20 分)02-线性结构3 Reversing Linked List (25 分)02-线性结构4 Pop Sequence (25 分) 02-线性结构1 两个有序链表序列的合并 (15 分) List Merge( List L1, List L2 )//合并函数本题需要写的函数 {...

CodingW的博客 336

Android System UI 深度解析:从架构演进到车载 / TV 场景的全维度定制

本文全面解析 Android System UI 的架构设计、功能演进及场景化定制,揭示其作为安卓系统核心交互层的技术特性与生态价值。

学无止境 1585

【深度学习新浪潮】李飞飞团队VAGEN框架深度解析:让VLM智能体学会“三思而后行“

VAGEN框架的真正价值,不仅在于性能指标的突破,更在于重新定义了VLM智能体的发展方向——人工智能的进步不应只追求"做得对",更要实现"想得清"。李飞飞团队通过强制显式思考、动态表示适配和精细化奖励三大创新,让智能体第一次具备了可解释的世界建模能力。正如人类通过"观察-预测-行动"认识世界,VAGEN为AI注入的这种思考范式,或许正是通往通用人工智能的关键一步。对于开发者而言,开源的VAGEN框架不仅提供了强大的工具,更揭示了一个重要理念:让AI学会思考,比让它学会执行更重要。

专注:太空算力、AI infra、异构调度、大模型成本工程 282

数据结构——浙大版中国大学mooc(week3)

树(上)03-树1 树的同构 (25 分)03-树2 List Leaves (25 分)03-树3 Tree Traversals Again (25 分) 03-树1 树的同构 (25 分) 题目:给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2,则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的,因为我们把其中一棵树的结点A、B、G的左右孩子互换后,就得到另外一棵树...

CodingW的博客 300

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

数据结构——浙大版中国大学mooc(week9)

排序(上)课程给出代码09-排序1 排序 (25 分)09-排序2 Insert or Merge (25 分)09-排序3 Insertion or Heap Sort (25 分) 课程给出代码 C语言:插入排序 void InsertionSort( ElementType A[], int N ) { /* 插入排序 */ int P, i; ElementType T...

CodingW的博客 403

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

数据结构——浙大版中国大学mooc(week1)

二分查找与最大子列和课程给出代码01-复杂度3 二分查找 (20 分)01-复杂度1 最大子列和问题 (20 分)01-复杂度2 Maximum Subsequence Sum (25 分) 课程给出代码 第一周的课程主要就是给出了一个例子即最大子数列和的问题,在这基础上提出了四种解决方案,其中第三种和第四种最为实用,下面代码给出的是第三种方法即分而治之。有点像二分法但采用了递归,对内存的损耗较大...

CodingW的博客 274

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

数据结构——浙大版中国大学mooc(week4)

树(中)课程给出代码课程给出代码课程给出代码课程给出代码课程给出代码 课程给出代码 C语言表示二叉搜索树的插入和搜索 BinTree Insert( BinTree BST, ElementType X ) { if( !BST ){ /* 若原树为空,生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)...

CodingW的博客 315

数据结构PTA 案例6-1.5 旅游规划

案例6-1.5 旅游规划题目解法 题目 有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。 输入格式: 输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:

Echooo的博客 2941

PTA练习题:旅游规划

有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。 输入格式: 输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:城市1、城市2、高速公路长度、收费额,中

weixin_45735242的博客 3402

数据结构PTA习题:07-图6 旅游规划 (25分)

07-图6 旅游规划 (25分) 有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。 输入格式: 输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:城市1

wulila的博客 2719

旅游规划问题

有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。输入数据的第 1 行给出 4 个正整数nmsd,其中n(2≤n≤500)是城市的个数,顺便假设城市的编号为 0~(n−1);m是高速公路的条数;s是出发地的城市编号;d是目的地的城市编号。随后的m。

2301_80937866的博客 1084

浙大数据结构习题笔记:07-图6 旅游规划 (25分)

有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。 输入格式: 输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:城市1、城市2、高速公路长度、收费额,中

Jimobbb的博客 663

数据结构与算法——7-9 旅游规划 (25分)

7-9 旅游规划 (25分) 有了一张自驾旅游路线图,你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序,帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的,那么需要输出最便宜的一条路径。 输入格式: 输入说明:输入数据的第1行给出4个正整数N、M、S、D,其中N(2≤N≤500)是城市的个数,顺便假设城市的编号为0~(N−1);M是高速公路的条数;S是出发地的城市编号;D是目的地的城市编号。随后的M行中,每行给出一条高速公路的信息,分别是:城市1、城

qazwsxxxxxasd的博客 1518
上一篇: 数据结构——浙大版中国大学mooc(week6)
下一篇: 数据结构——浙大版中国大学mooc(week8)
CodingW
博客等级 码龄8年 3粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值