用C++或java代码写出

为了实现这个简单的工程调度问题，我们可以按照以下步骤来编写代码：

1. **输入任务信息**：包括任务的长度、所需资源种类及数量。
2. **构建DAG图**：使用邻接矩阵或邻接表来表示任务之间的依赖关系。
3. **资源调度算法**：基于贪心策略或其他高效算法来安排任务，确保资源限制条件得到满足。
4. **输出结果**：生成甘特图并显示任务的开始时间和结束时间。

以下是使用C++实现的一个示例代码：

#include <iostream>
#include <vector>
#include <queue>
#include <map>

using namespace std;

struct Task {
    int id;
    int duration;
    map<int, int> resources; // resource_id -> required_amount
};

class Scheduler {
public:
    void addTask(int id, int duration, const map<int, int>& resources) {
        tasks[id] = {id, duration, resources};
    }

    void addDependency(int from, int to) {
        graph[from].push_back(to);
        inDegree[to]++;
    }

    bool schedule(int totalResources) {
        vector<int> order;
        queue<int> q;

        for (auto& task : tasks) {
            if (inDegree[task.first] == 0) {
                q.push(task.first);
            }
        }

        while (!q.empty()) {
            int taskID = q.front();
            q.pop();

            if (!canSchedule(taskID, totalResources)) {
                return false;
            }

            order.push_back(taskID);

            for (int nextTask : graph[taskID]) {
                inDegree[nextTask]--;
                if (inDegree[nextTask] == 0) {
                    q.push(nextTask);
                }
            }
        }

        if (order.size() != tasks.size()) {
            return false; // Cycle detected
        }

        printGanttChart(order, totalResources);
        return true;
    }

private:
    map<int, Task> tasks;
    vector<vector<int>> graph;
    map<int, int> inDegree;

    bool canSchedule(int taskID, int totalResources) {
        for (const auto& [resourceID, amount] : tasks[taskID].resources) {
            if (amount > totalResources) {
                return false;
            }
        }
        return true;
    }

    void printGanttChart(const vector<int>& order, int totalResources) {
        cout << "Gantt Chart:" << endl;
        cout << "Time: ";
        for (int time = 0; time <= totalTime(order); time++) {
            cout << time << " ";
        }
        cout << endl;

        for (int resource = 0; resource < totalResources; resource++) {
            cout << "Resource " << resource + 1 << ": ";
            for (int time = 0; time <= totalTime(order); time++) {
                for (const auto& taskID : order) {
                    if (time >= startTime[taskID] && time < endTime[taskID] && tasks[taskID].resources.count(resource + 1)) {
                        cout << "T" << taskID << " ";
                        break;
                    } else if (tasks[taskID].resources.count(resource + 1)) {
                        cout << "  ";
                    }
                }
            }
            cout << endl;
        }
    }

    int totalTime(const vector<int>& order) {
        int maxEndTime = 0;
        for (const auto& taskID : order) {
            maxEndTime = max(maxEndTime, endTime[taskID]);
        }
        return maxEndTime;
    }

    map<int, int> startTime;
    map<int, int> endTime;

    void calculateStartAndEndTimes(const vector<int>& order) {
        int currentTime = 0;
        for (const auto& taskID : order) {
            startTime[taskID] = currentTime;
            endTime[taskID] = currentTime + tasks[taskID].duration;
            currentTime += tasks[taskID].duration;
        }
    }
};

int main() {
    Scheduler scheduler;

    // Add tasks
    scheduler.addTask(1, 3, {{1, 2}});
    scheduler.addTask(2, 2, {{1, 1}, {2, 1}});
    scheduler.addTask(3, 4, {{2, 2}});

    // Add dependencies
    scheduler.addDependency(1, 2);
    scheduler.addDependency(2, 3);

    // Schedule with total resources
    int totalResources = 3;
    if (scheduler.schedule(totalResources)) {
        cout << "Scheduling successful." << endl;
    } else {
        cout << "Scheduling failed." << endl;
    }

    return 0;
}

### 说明
1. **Task 结构体**：存储任务的ID、持续时间和所需资源。
2. **Scheduler 类**：
- `addTask` 方法用于添加任务及其相关信息。
- `addDependency` 方法用于添加任务之间的依赖关系。
- `schedule` 方法执行调度算法，并检查是否可以成功调度所有任务。
- `printGanttChart` 方法用于打印甘特图。
3. **主函数**：创建任务和依赖关系，并调用 `schedule` 方法进行调度。

这个示例代码展示了如何实现一个简单的工程调度系统，你可以根据具体需求进一步优化和扩展功能。