月球美容计划之最短路

那HDU的2544作为复习最短路的题目,用不同算法。

迪杰斯特拉

有点像普利姆算法的精简版,不能有负权边

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 99999
#define qmin(a,b) a > b ? b : a

//最短路
//迪杰斯特拉

int G[200][200];
int vis[200];

int djs (int n,int s)
{
    int d[200];
    memset(vis,0,sizeof(vis));
    int i,k;
    for (i = 1;i <= n;i++)
        d[i] = G[1][i];
    d[1] = 0;
    vis[1] = 1;

    int imin,xb = 1;
    for (i = 1;i < n;i++)
    {
        imin = MAX;
        for (k = 1;k <= n;k++)						//以xb为起点↓
            if (!vis[k] && d[xb] + G[xb][k] < d[k])  //最短的那条边,快到碗里来
                d[k] = d[xb] + G[xb][k];

        vis[xb] = 1;

        for (k = 1;k <= n;k++)
            if (!vis[k] && imin > d[k])
                imin = d[xb = k];           //找到最小的点,并以此为起点找最短
        vis[xb] = 1;
    }
    return d[n];
}

int main()
{
    int n,m;

    while (scanf ("%d%d",&n,&m),n || m)
    {
        int i,k;

        for (i = 0;i <= n;i++)
            for (k = 0;k <= n;k++)
                if (i == k)
                    G[i][k] = 0;
                else
                    G[i][k] = MAX;

        for (i = 0;i < m;i++)
        {
            int a,b,c;
            scanf ("%d%d%d",&a,&b,&c);
            if (c < G[a][b])
            {
                G[a][b] = c;
                G[b][a] = c;
            }
        }

        int ans = djs(n,1);

        printf ("%d\n",ans);
    }
    return 0;
}

 

贝尔曼福特

可以有负权边,就是不停的松弛,时间复杂度有点高

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 99999
#define qmin(a,b) a > b ? b : a

//最短路
//贝尔曼福特

struct E
{
    int e,v;
    int w;
}e[10000];

int cont;

int BF (int n,int s)
{
    int d[200];
    int i,k;
    for (i = 0;i <= n;i++)
        d[i] = MAX;

    d[s] = 0;

    for (i = 1;i < n;i++)     //找n - 1条边
    {
        for (k = 0;k < cont;k++)  //把每条边都遍历一遍
        {
            int a = e[k].e,b = e[k].v;
            d[b] = qmin (d[b],d[a] + e[k].w);  //松弛
        }
    }

    return d[n];
}

int main()
{
    int n,m;

    while (scanf ("%d%d",&n,&m),n || m)
    {
        int i,k;

        cont = 0;
        for (i = 0;i < m;i++)
        {
            int a,b,c;
            int tf = 1;
            scanf ("%d%d%d",&a,&b,&c);

            for (k = 0;k < cont;k++)
                if ((e[k].e == a && e[k].v == b) || (e[k].e == b && e[k].v == a))
                    if (e[k].w > c)
                    {
                        e[k].w = c;
                        tf = 0;
                        break;
                    }

            if (tf)
            {
				//无向图
                e[cont].e = a;
                e[cont].v = b;
                e[cont++].w = c;
                e[cont].e = b;
                e[cont].v = a;
                e[cont++].w=c;
            }
        }

        int ans = BF(n,1);

        printf ("%d\n",ans);
    }
    return 0;
}


 

弗洛伊德

这简直就像暴力啊,时间复杂度大的夸张,但是求出了每两个点之间的最短路,对于数据多而且图小的题目还是可以考虑的。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 99999
#define qmin(a,b) a > b ? b : a

//最短路
//弗洛伊德

int G[200][200];

int fld (int n,int s)
{
    int d[200][200];
    int i,j,k;
    memcpy(d,G,sizeof (G));

    for (i = 0;i <= n;i++)
        for (k = 0;k <= n;k++)
            for (j = 0;j <= n;j++)
                d[k][j] = qmin (d[k][j],d[k][i] + d[i][j]);

    return d[s][n];
}

int main()
{
    int n,m;

    while (scanf ("%d%d",&n,&m),n || m)
    {
        int i,k;

        //邻接矩阵初始化

        for (i = 0;i <= n;i++)
            for (k = 0;k <= n;k++)
                if (i == k)
                    G[i][k] = 0;
                else
                    G[i][k] = MAX;

        for (i = 0;i < m;i++)
        {
            int a,b,c;
            scanf ("%d%d%d",&a,&b,&c);

            if (G[a][b] > c)
            {
                G[a][b] = c;
                G[b][a] = c;
            }
        }

        int ans = fld(n,1);

        printf ("%d\n",ans);
    }
    return 0;
}


 

SPFA

BF的队列优化,有点像BFS。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 99999
#define qmin(a,b) a > b ? b : a

//最短路
//SPFA

struct node
{
    int v;
    int w;
    struct node *next;
}head[10001];

int q[1000000];   //队列
int s = 0,e = 0;
int SPFA (int n,int st)
{
    bool inq[200];  //标记是否还在队列中(队列中的不在入队列)
    int d[200];
    int i;

    memset (inq,0,sizeof (inq));
    for (i = 0;i <= n;i++)
        d[i] = MAX;
    s = 0;
    e = 0;
    d[st] = 0;
    q[s++] = st;
    inq[st] = 1;    //源点入队列并标记
    while (s > e)
    {
        int now = q[e++];
        inq[now] = 0;  //出队列的就恢复标记

        struct node *p = head[now].next;

        while (p != NULL)
        {
            if(d[p->v] > d[now] + p->w)  //松弛成功
            {
                d[p->v] = d[now] + p->w;

                if (!inq[p->v])         //如果在队列中就不入队列
                {
                    q[s++] = p->v;
                    inq[p->v] = 1;
                }
            }
            p = p->next;
        }
    }
    return d[n];          //其他的和BF一样了
}

int add (int a,int b,int c)    //邻接链表
{
    struct node *t = new node;
    t->v = b;
    t->w = c;
    t->next = NULL;

    struct node *p = &head[a];

    while (p->next != NULL)
        p = p->next;

    p->next = t;

    return 1;
}

int main()
{
    int n,m;

    while (scanf ("%d%d",&n,&m),n || m)
    {
        memset(head,0,sizeof (head));
        int i,k;

        for (i = 0;i < m;i++)
        {
            int a,b,c;
            int tf = 1;
            scanf ("%d%d%d",&a,&b,&c);

            add (a,b,c);
            add (b,a,c);
        }

        int ans = SPFA(n,1);

        printf ("%d\n",ans);
    }
    return 0;
}


SPFA前向星版本

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#define EGMAX 200000
#define DOMAX 2000
#define MAX 999999

using namespace std;

struct node
{
    int e;
    int w;
    int next;
}eg[EGMAX];

int head[DOMAX];

int cont;
void add(int s,int e,int w)
{
    eg[cont].e = e;
    eg[cont].w = w;
    eg[cont].next = head[s];
    head[s] = cont++;
}

int dis[DOMAX];
bool vis[DOMAX];

int SPFA(int s,int e,int n)
{

    int now;
    queue<int> que;
    memset(vis,0,sizeof (vis));
    for (int i = 0;i <= n;i++)
        dis[i] = MAX;

    vis[s] = 1;
    dis[s] = 0;
    que.push(s);

    while (!que.empty())
    {
        now = que.front();
        que.pop();
        vis[now] = 0;

        for (int i = head[now];~i;i = eg[i].next)
        {
            if (dis[eg[i].e] > dis[now] + eg[i].w)
            {
                dis[eg[i].e] = dis[now] + eg[i].w;

                if (!vis[eg[i].e])
                {
                    vis[eg[i].e] = 1;
                    que.push(eg[i].e);
                }
            }
        }
    }

    return dis[e];

}

int main()
{
    int n,m;
    
    while (~scanf ("%d%d",&n,&m) && (n || m))
    {
        cont = 0;
        memset(head,-1,sizeof (head));
        for(int i = 0;i < m;i++)
        {
            int s,e,w;
            scanf ("%d%d%d",&s,&e,&w);
            add(s,e,w);
            add(e,s,w);
        }

        int ans = SPFA(1,n,n);

        printf ("%d\n",ans);
    }
    return 0;
}


http://blog.youkuaiyun.com/codehypo

<think>嗯,用户想了解如何使用Arduino实现月壤制氧的项目或方案,特别是模拟代码。首先,我得先理清楚月壤制氧的基本原理。月壤中含有氧化物,比如二氧化硅、氧化铁等,通过高温分解或者电解的方法可以释放氧气。Arduino在这个项目中可能用于控制温度、监测传感器数据以及管理电解过程。 然后,用户提到的Arduino平台有硬件限制,比如处理能力、存储和I/O接口,这可能影响复杂任务的执行。所以设计方案时要尽量简化,使用基本的传感器和执行器,比如温度传感器、加热元件、电解槽控制等。 接下来,模拟代码的结构。可能需要几个部分:数据采集(温度、压力)、加热控制(PID或简单开关控制)、电解控制、安全监控(超温报警)、数据输出。代码要模块化,方便调试和扩展。 考虑到Arduino的局限性,比如无法真实模拟月球环境,代码中可能需要模拟传感器数据,或者使用简单的数字输入代替实际传感器。同时,要注意资源管理,避免复杂的计算导致性能问题。 用户可能还关心如何验证方案的可行性,可能需要参考已有的研究或类似项目。比如引用中的月壤制氧项目,可能涉及具体的化学反应和工程挑战,这些在代码中如何体现。 后,生成相关问题时要围绕实现方案的可能难点、硬件选择、优化方法、验证方式以及扩展应用,帮助用户深入理解项目的各个方面。</think>根据Arduino月球基地项目的技术特点和限制[^1],以下是月壤制氧项目的模拟实现方案: ### 一、基础方案设计 1. **核心原理** 通过高温电解法分解月壤中的金属氧化物,反应式: $$2MO \rightarrow 2M + O_2↑$$ 其中M代表金属元素如Fe、Si等[^1] 2. **硬件模块** - Arduino UNO主控 - K型热电偶(MAX6675模块) - 继电器控制加热装置 - 电解槽电压控制模块 - MQ-131氧传感器 - LCD1602显示屏 ### 二、模拟代码框架 ```arduino #include <MAX6675.h> #include <LiquidCrystal.h> // 初始化模块 MAX6675 thermocouple(3,4,5); // CLK,CS,DO LiquidCrystal lcd(7,8,9,10,11,12); // 引脚定义 const int HEATER_PIN = 6; const int ELECTRO_PIN = A0; const int O2_SENSOR = A1; void setup() { pinMode(HEATER_PIN, OUTPUT); lcd.begin(16,2); Serial.begin(9600); } void loop() { float temp = thermocouple.readCelsius(); int o2_level = analogRead(O2_SENSOR); // 温度控制(简化PID) if(temp < 800) { // 目标温度800°C digitalWrite(HEATER_PIN, HIGH); } else { digitalWrite(HEATER_PIN, LOW); } // 电解控制(占空比调节) analogWrite(ELECTRO_PIN, map(temp, 700, 900, 100, 255)); // 数据显示 lcd.setCursor(0,0); lcd.print("Temp:" + String(temp)); lcd.setCursor(0,1); lcd.print("O2:" + String(o2_level*0.1) + "%"); delay(1000); } ``` ### 三、关键实现逻辑 1. **温度控制** 采用开关控制维持$800±50°C$反应温度区间,实际应用建议改用PID算法[^1] 2. **电解优化** 根据温度反馈动态调节电解电压: $$V_{electro} = k \times (T_{target} - T_{actual})$$ 其中$k$为比例系数 3. **安全监控** 设置硬件看门狗防止系统死机,添加温度硬限制保护电路
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值