主持人调度（一）

C++ 解法, 执行用时: 72ms, 内存消耗: 11392KB, 提交时间: 2022-07-09

static const auto io_sync_off = [](){
    std::ios::sync_with_stdio(false);
    std::cout.tie(nullptr);
    std::cin.tie(nullptr);
    return nullptr;
}();
class Solution {
public:
    static bool cmp(vector<int>& a,vector<int>& b)
    {
        return a[0]<b[0];
    }
    bool hostschedule(vector<vector<int> >& schedule) {
        if(schedule.size()==1)
            return true;
        sort(schedule.begin(),schedule.end(),cmp);
        vector<vector<int>>res;
        int t=schedule[0][1];
        for(int i=1;i<schedule.size();i++)
        {
            if(schedule[i][0]<t)
                return false;
            else t=schedule[i][1];
        }
        return true;
    }
};

C 解法, 执行用时: 83ms, 内存消耗: 9580KB, 提交时间: 2022-04-09

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param schedule int整型二维数组 
 * @param scheduleRowLen int schedule数组行数
 * @param scheduleColLen int* schedule数组列数
 * @return bool布尔型
 *
 * C语言声明定义全局变量请加上static，防止重复定义

*/

typedef struct{
    int start;
    int end;
}Time;

int cmp(const void*a, const void *b)
{
    Time *x = (Time*)a;
    Time *y = (Time*)b;
    return x->start - y->start;
}

bool hostschedule(int** schedule, int scheduleRowLen, int* scheduleColLen ) {
    // write code here
    * scheduleColLen = 2;
    Time *tmp = (Time *)malloc(sizeof(Time) *scheduleRowLen);
    for(int i = 0; i < scheduleRowLen;i++){
       tmp[i].start = schedule[i][0];
       tmp[i].end = schedule[i][1];
    }
    qsort(tmp, scheduleRowLen, sizeof(Time), cmp);
    
    for(int i =0; i < scheduleRowLen; i++){
       // printf("%d %d\n", tmp[i].start,tmp[i].end);
        if(i + 1 >= scheduleRowLen){
            break;
        }
        if(tmp[i].end > tmp[i+1].start){
            return false;
        }
    }
    return true;
}

C 解法, 执行用时: 84ms, 内存消耗: 9516KB, 提交时间: 2022-07-18

typedef struct {
    int start;
    int end;
} Time;

int cmp(const void* a, const void* b) {
    Time* x = (Time*)a;
    Time* y = (Time*)b;
    return x->start - y->start;
}

bool hostschedule(int** schedule, int scheduleRowLen, int* scheduleColLen ) {
    * scheduleColLen = 2;
    Time* t = (Time*)malloc(sizeof(Time) * scheduleRowLen);
    for (int i = 0; i < scheduleRowLen; i++) {
        t[i].start = schedule[i][0];
        t[i].end = schedule[i][1];
    }
    qsort(t, scheduleRowLen, sizeof(Time), cmp);
    for (int i = 0; i < scheduleRowLen; i++) {
        if (i + 1 >= scheduleRowLen) {
            break;
        }
        if (t[i].end > t[i + 1].start) {
            return false;
        }
    }
    return true;
}

C 解法, 执行用时: 84ms, 内存消耗: 9580KB, 提交时间: 2022-06-16

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param schedule int整型二维数组 
 * @param scheduleRowLen int schedule数组行数
 * @param scheduleColLen int* schedule数组列数
 * @return bool布尔型
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */
#include <stdbool.h>

int cmp(const void *a, const void *b) {
    return (**(int **)(a)) - (**(int **)(b));    
}

void quickSort(int** schedule, int start, int end) {
    if (start < end) {
        int *target = schedule[start], i = start, j = end, flag = 1;
        while(i < j) {
//             while(i < j && (schedule[j][0] > target[0] || (schedule[j][0] == target[0] && flag == 1))) {
//                 if(schedule[j][0] == target[0]) {
//                     flag = 0;
//                 }
            while(i < j && schedule[j][0] > target[0]) {
                j--;
            }
            if(i < j) {
                schedule[i++] = schedule[j];
            }
//             while(i < j && (schedule[i][0] < target[0] || (schedule[i][0] == target[0] && flag == 0))) {
//                 if(schedule[i][0] == target[0]) {
//                     flag = 1;
//                 }
            while(i < j && schedule[i][0] <= target[0]) {
                i++;
            }
            if(i < j) {
                schedule[j--] = schedule[i];
            }
        }
        schedule[i] = target;
        
        quickSort(schedule, start, i - 1);
        quickSort(schedule, i + 1, end);
    }
}

bool hostschedule(int** schedule, int scheduleRowLen, int* scheduleColLen ) {
    if (scheduleRowLen <= 1) {
        return true;
    }
    
    qsort(schedule, scheduleRowLen, sizeof(int) * (*scheduleColLen), cmp);
    
    //quickSort(schedule, 0, scheduleRowLen - 1);
    
    for (int i = 0; i < scheduleRowLen - 1; i++) {
        if (schedule[i+1][0] < schedule[i][1]) {
            return false;
        }
    }
    
    return true;
}

C 解法, 执行用时: 88ms, 内存消耗: 9496KB, 提交时间: 2022-05-05

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param schedule int整型二维数组 
 * @param scheduleRowLen int schedule数组行数
 * @param scheduleColLen int* schedule数组列数
 * @return bool布尔型
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */
static void quickSort(int** schedule, int start, int end) {
    if (start >= end) return;
    int i = start;
    int j = end;
    int pivot = schedule[i][0];
    
    while (i < j) {
        while (schedule[j][0] > pivot && j > i) --j;
        while (schedule[i][0] <= pivot && i < j) ++i;
        
        if (i < j) {
            int tmp1 = schedule[j][0];
            int tmp2 = schedule[j][1];
            schedule[j][0] = schedule[i][0];
            schedule[j][1] = schedule[i][1];
            schedule[i][0] = tmp1;
            schedule[i][1] = tmp2;
        }
    }
    
    int tmp1 = schedule[j][0];
    int tmp2 = schedule[j][1];
    schedule[j][0] = schedule[start][0];
    schedule[j][1] = schedule[start][1];
    schedule[start][0] = tmp1;
    schedule[start][1] = tmp2;
    
    quickSort(schedule, start, j-1);
    quickSort(schedule, j+1, end);
}

static int cmp2(const void* a, const void* b) {
    int** tmp1 = (int**)a;
    int** tmp2 = (int**)b;
    return (*tmp1[0] - *tmp2[0]);
}

int hostschedule(int** schedule, int scheduleRowLen, int* scheduleColLen ) {
    // write code here
//     quickSort(schedule, 0, scheduleRowLen-1);
    qsort(schedule, scheduleRowLen, sizeof(schedule[0]), cmp2);
    
    int arr[12][2];
    int j;
    for (j = 0; j < 12; j++) {
        arr[j][0] = schedule[j][0];
        arr[j][1] = schedule[j][1];
    }
    int i;    
    for (i = 1; i < scheduleRowLen; i++) {
        if (schedule[i][0] < schedule[i-1][1]) return 0;
    }
    return 1;
}

详情