编程题目-汇总

快速排序算法选主元

 

//vector<int> numbers = {1,3,2,4,5};

#include<algorithm>

class Solution {
public:
    // 待实现函数，在此函数中填入答题代码;
    vector<int> QuickSort(const vector<int>& numbers)
    {
        vector<int> result;
        int size = numbers.size();
        vector<int> result1(size);
        vector<int> result2(size);
        result1[0]=numbers[0];
        result2[size-1]=numbers[size-1];

        for (int i = 1; i < size; ++i) {
            result1[i] = max(numbers[i], result1[i-1]);
            result2[size-1-i] = min(numbers[size-1-i], result2[size-i]);
        }

        for (int i = 0; i < size; ++i) {
            if (numbers[i] >= result1[i] && numbers[i] <= result2[i]) {
                result.push_back(numbers[i]);
            }
        }
        sort(result.begin(), result.end());
        return result;
    }
};

inline int ReadInt()
{
    int number;
    cin >> number;
    return number;
}

template<typename T>
inline vector<T> ReadVector(int size)
{
    vector<T> objects(size);
    for (int i = 0; i < size; ++i) {
        cin >> objects[i];
    }
    return objects;
}

template <typename T> inline void WriteVector(const vector<T> &objects, char delimeter = ' ')
{
    auto it = objects.begin();
    if (it == objects.end()) {
        return;
    }
    cout << *it;
    for (++it; it != objects.end(); ++it) {
        cout << delimeter << *it;
    }
}

int main()
{
    //int numbersNum = ReadInt();
    int numbersNum = 5;
    //vector<int> numbers = ReadVector<int>(numbersNum);
    vector<int> numbers = {1,3,2,4,5};
    Solution solu;
    auto res = solu.QuickSort(numbers);
    cout << "[";
    WriteVector(res, ' ');
    cout << "]" << endl;
    return 0;
}

 

 

cd目录

class Solution {
public:
    string fix_string(string &src)
    {

        string tmp1;
        for (int i = 0; i < src.length(); ++i) {
            if (src[i] == '/' &&
                !tmp1.empty() &&
                tmp1.back() == '/') {
                continue;
            }
            tmp1.push_back(src[i]);
        }

        string tmp2;
        for (int i = 0; i < tmp1.length(); ++i) {
            if (tmp1[i] == '.' && tmp1[i+1] == '/' ) {
                i++;
                continue;
            }
            if (tmp1[i] == '.' && tmp1[i+1] == '.' ) {
                i++;
                tmp2.erase(tmp2.length()-1);
                while (tmp2.back() != '/') {
                    tmp2.erase(tmp2.length()-1);
                }
                continue;
            }
            tmp2.push_back(tmp1[i]);
        }

        string tmp3;
        for (int i = 0; i < tmp2.length(); ++i) {
            if (tmp2[i] == '/' &&
                !tmp3.empty() &&
                tmp3.back() == '/') {
                continue;
            }
            tmp3.push_back(tmp2[i]);
        }

        if (tmp3.size()>1 && tmp3.back() == '/')
            tmp3.erase(tmp3.size() - 1);

        return tmp3;
    }

    queue<string> que;

    void push_queue(string str)
    {
        que.push(str);
        if (que.size() > 2) {
            que.pop();
        }
    }

    string GetCurrentDirectory(const vector<string>& cmds)
    {
        string currentPath;

        for (auto c : cmds) {
            c = c.substr(3);

            if (c.length() < 1) {
                currentPath = "/home/user";
                push_queue(currentPath);
                continue;
            }

            if (c[0] == '-') {
                currentPath = que.front();
                push_queue(currentPath);
            } else if (c[0] == '/') {
                if (c.back() != '/')
                    c.append("/");
                currentPath = c;
                push_queue(currentPath);
            } else {
                if (c.back() != '/')
                    c.append("/");
                currentPath = que.back() + c;
                push_queue(currentPath);
            }

        }

        currentPath = fix_string(currentPath);

        return currentPath;
    }
};

int main()
{
    //string line;
    //getline(cin, line);
    //int num = stoi(line);
    int num = 3;
    vector<string> cmds;
//    for (int loop = 0; loop < num; loop++) {
//        getline(cin, line);
//        cmds.push_back(line);
//    }

    cmds.push_back("cd /aa/bb/cc/dd/");
    cmds.push_back("cd ./ee/ff");
    cmds.push_back("cd .");
    //cmds.push_back("cd /");
    cmds.push_back("cd gg/../hh");
    cmds.push_back("cd -");

//    cmds.push_back("cd /aa/bb//");
//    cmds.push_back("cd ..");
//    cmds.push_back("cd -");

//    cmds.push_back("cd ");
//    cmds.push_back("cd ..");


    Solution parser;
    cout << parser.GetCurrentDirectory(cmds) << endl;
    return 0;
}

 

终端公司的零售店需要定期去仓库提取货物，假设零售店和仓库在一个矩阵上，相邻点的距离为1，只能通过上下左右走动，矩阵的UAN速度值仅为3种，0表示仓库，-1表示障碍，1表示零售店，注，找障碍表示无法通过，其他可以通过。

为了将取货效率最大化，需要计算每个零售店走到最近仓库的最小距离，并输出这些最小距离的和：

无法到达仓库的零售店，不参与距离的计算

没有零售店或者仓库的话，返回0.

第一行为两个数字m和n，表示数组的行数和列数，m和n,

接下来的m行表示一个m*n的数组，每行的元素间以空格分割。

输出：

一个整数，表示所计算的最小距离之和

输入

3 3
1 -1 0
0 1 1
1 -1 1
输出
6

输入

2 3
0 -1 1
1 -1 1
输出1

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    // 待实现函数，在此函数中填入答题代码
    int NearestWareHouse(const vector<vector<int>>& grid)
    {

        vector<pair<int,int>> sales;
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < grid.front().size(); ++j) {
                if (grid[i][j] == 1)
                    sales.push_back(make_pair(i,j));
            }
        }
        return 0;
    }
};

// 以下为考题输入输出框架，此部分代码不建议改动
template<typename T>
inline std::vector<T> ReadVector(int size)
{
    std::vector<T> objects(size);
    for (int i = 0; i < size; ++i) {
        std::cin >> objects[i];
    }
    return objects;
}

int main()
{
    int m = 0;
    int n = 0;
    cin >> m >> n;
    vector<vector<int>> grid;

    while (m > 0) {
        auto row = ReadVector<int>(n);
        if (!row.empty()) {
            grid.push_back(row);
            m--;
        }
    }

    Solution solu;
    int got = solu.NearestWareHouse(grid);
    cout << got << endl;

    return 0;
}