华为fx测试题

1.
小K是X区域的销售经理，他平常常驻“5”城市，并且经常要到“1”、“2”、“3”、“4”、“6”城市出差。当机场出现大雾情况时，会导致对应城市的所有航班的起飞及降落均停止（即不能从该城市出发，其他城市也不能到达该城市）。小K希望知道如果他需要到X城市出差时，如果遇到Y城市出现大雾，他最短的飞行时间及飞行路径。

注意：当两个城市间不可达时，消耗时间默认取1000.

各城市简的飞行时间如下表所示，加粗行代表始发城市，加粗列代表终点城市，矩阵中的值代表从始发城市飞到终点城市所耗时间（单位：小时），M代表不可达（注意飞行线程是单向的，即A->B不等于B->A），例如

（1）从1号城市飞行到4号城市花费5h，从4号城市飞到1号城市花费2h

（2）从5号城市飞行到3号城市不可达，从3号城市飞到5号城市花费7h

 1    2    3    4    5    6

1 0h 2h 10h 5h 3h M

2 M 0h 12h M M 10h

3 M M 0h M 7h M

4 2h M M 0h 2h M

5 4h M M 1h 0h M

6 3h M 1h M 2h 0h

输入描述：

输入出差城市X（X可为1、2、3、4、6）

输入大雾城市（Y可为0、1、2、3、4、5、6，可为0时代表没有城市出现大雾）

#include<cstdio>  
#include<cstring>  
#include<algorithm> 
#include<string>
#include<iostream>  
#include<string>  
#include<vector>  
#include<stack>  
#include<bitset>  
#include<cstdlib>  
#include<cmath>  
#include<set>  
#include<list>  
#include<deque>  
#include<map> 
#include<unordered_map>
#include<queue>
#include<iomanip>
using namespace std;
typedef long long ll;
const double PI = acos(-1.0);
const double eps = 1e-6;

int INF = 1000;
vector<vector<int>>dist(6, vector<int>(6));
vector<vector<int>>path(6, vector<int>(6));
deque<int>result;
void setFog(vector<vector<int>>&matrix, int city) {
            for (int i = 0; i < matrix.size(); i++) {
                     matrix[i][city] = matrix[city][i] = INF;
    }
}
void floyd(vector<vector<int>>&matrix) {
    int size = matrix.size();
    for (int i = 0; i < size; i++)
        for (int j = 0; j < size; j++) {
            path[i][j] = -1;
            dist[i][j] = matrix[i][j];
        }
    for (int k = 0; k < size; k++) {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (dist[i][k] != INF && dist[k][j] != INF
                    && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                    path[i][j] = k;
                }
            }
        }
    }
}
void findPath(int i, int j) {
    int ci = i, ccj = j;
    while (path[i][j] != -1) {
        int cj = path[i][j];
        result.push_back(cj);
        i = cj;
    }
    result.push_front(ci);
    result.push_back(ccj);
}

int main()
{
    vector<vector<int>>matrix = { { 0, 2, 10, 5, 3, INF },
                       { INF, 0, 12, INF, INF, 10 }, { INF, INF, 0, INF, 7, INF },
                         { 2, INF, INF, 0, 2, INF }, { 4, INF, INF, 1, 0, INF },
                         { 3, INF, 1, INF, 2, 0 } };

    int end, foggy;
    cin >> end >> foggy;
    --end;
    --foggy;
    if (foggy!=-1)
        setFog(matrix, foggy);
    floyd(matrix);
      findPath(4, end);
       cout << dist[4][end] << endl;
       for (int i = 0; i < result.size(); i++)
            ++result[i];    
       if (dist[4][end] == INF)
           result.clear();
       if (result.empty())
           cout << "[]" << endl;
       else
       {
           cout << "[";
           for (int i = 0; i < result.size() - 1; ++i)
               cout << result[i] << ", ";
           cout << result.back() << "]" << endl;
       }
    return 0;
}

---

2.
题目描述：输入5个任务的ID，任务优先级，开始运行时间和任务运行时间，其中调度过程支持抢占，即优先级值高的任务可抢占正在运行的优先级值低的任务，最后输出前200秒，任务的调度过程

输入描述：任务信息输入格式为：[任务ID.任务优秀级.任务开始运行时间.任务运行时长]；任务与任务之间使用“|”隔离；5个任务的任务ID为1-5；任务优先级范围为0-200.

输入例子：[1.80.1.10]|[2.20.11.15]|[3.50.21.10]|[4.120.31.10]|[5.100.41.10]

输出描述:任务ID.任务运行时长;任务之间使用”|”分割;如无任务运行,则任务id为0;
输出例子：0.1|1.10|2.10|3.10|4.10|5.10|2.5|0.144

大致思想就是先把任务按照时间排序.然后先放最前面的任务,看下一个任务开始的时间是否有任务在执行,之后比较优先级,如果优先级高就先执行下一个任务,第一个任务顺延.依次类推

也可以按照任务的优先级程度进行排序,然后最高的先执行,之后执行次高的如果时间不为0,则被之前的分段.

#include <iostream>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <map>
#include <limits.h>

using namespace std;

int main()
{
    int task[5][4] = { 0 };
    scanf("[%d.%d.%d.%d]|[%d.%d.%d.%d]|[%d.%d.%d.%d]|[%d.%d.%d.%d]|[%d.%d.%d.%d]",
        &task[0][0], &task[0][1], &task[0][2], &task[0][3],
        &task[1][0], &task[1][1], &task[1][2], &task[1][3],
        &task[2][0], &task[2][1], &task[2][2], &task[2][3],
        &task[3][0], &task[3][1], &task[3][2], &task[3][3],
        &task[4][0], &task[4][1], &task[4][2], &task[4][3]);
for (int i = 0; i < 5; i++){
        int min = INT_MAX;
        int id = i;
        for (int j = i; j < 5; j++)
        {
            if (task[j][2] < min)
            {
                min = task[j][2];
                id = j;
            }
        }
        for (int k = 0; k < 4; ++k)
            swap(task[i][k], task[id][k]);
    }
    int time[200] = { 0 };
    for (int i = 0; i < 5; i++)
    {
        int start = task[i][2];
        if (start >= 200)
            break;
        if (time[start] == 0)
        {
            for (int j = 0; j < task[i][3]; j++)
            {
                if (start + j >= 200) break;
                time[start + j] = task[i][0];
            }
        }
        else
        {
            int pro = 0;
            int now = time[start];
            while (pro == 0 && (start < 200 && time[start] != 0))
            {
                for (int j = 0; j < 5; j++)
                {
                    if (task[j][0] == now && task[i][1] > task[j][1])
                        pro = 1;
                }
                if (pro == 0)
                {
                    while (start < 200 && time[start] == now)
                    {
                        start++;
                    }
                }
                now = time[start];
            }
            if (time[start] == 0)
            {
                for (int j = 0; j < task[i][3]; j++)
                {
                    if (start + j >= 200) break;
                    time[start + j] = task[i][0];
                }
            }
            else
            {
                int s = start;
                while (time[s] != 0)
                    s++;
                for (int j = s - 1; j >= start; j--)
                {
                    if (j + task[i][3] >= 200)
                        continue;
                    time[j + task[i][3]] = time[j];
                }
                for (int j = 0; j < task[i][3]; j++)
                {
                    if (start + j >= 200) break;
                    time[start + j] = task[i][0];
                }
            }
        }
    }
    int cnt;
    int now;
    for (int i = 0; i < 200; i++)
    {
        if (i == 0)
        {
            now = time[i];
            printf("%d.", now);
            cnt = 1;
        }
        else
        {
            if (time[i] == now)
            {
                cnt++;
            }
            else
            {
                printf("%d|", cnt);
                cnt = 1;
                now = time[i];
                printf("%d.", now);
            }
        }
    }
    printf("%d", cnt);
}