8张表:

SELECT * FROM act_re_deployment;   -- 一 流程部署表

SELECT * FROM act_ge_bytearray;    -- 二 流程二进制表

SELECT * FROM act_re_procdef;      -- 三 流程定义表

SELECT * FROM act_ru_execution;    -- 四 流程正在运行表

SELECT * FROM act_hi_procinst;     -- 五 流程实例历史表

SELECT * FROM act_ru_task;         -- 六 流程当前任务表

SELECT * FROM act_hi_taskinst;     -- 七 流程历史任务表

SELECT * FROM act_hi_actinst;      -- 八 流程历史活动节点表

先决工作:

//定义一个成员变量
    RepositoryService repositoryService;
    
    RuntimeService runtimeService;
    
    TaskService taskService;
    
    /**
     * 获取流程引擎
     */
    @Before
    public void setUp() throws Exception {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        repositoryService = processEngine.getRepositoryService();
        runtimeService = processEngine.getRuntimeService();
        taskService = processEngine.getTaskService();
    }

1 启动流程

测试代码:

/**
     * 启动流程
     */
    @Test
    public void startProcess() {
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("activiti_leave");
        String processInstanceId = processInstance.getId();
        String activityId = processInstance.getActivityId();
        String definitionId = processInstance.getProcessDefinitionId();
        
        System.out.println("流程实例ID："+processInstanceId);
        System.out.println("正在活动的节点ID："+activityId);
        System.out.println("流程定义ID："+definitionId);
    }

2 查询正在运行的实例

测试代码:

/**
     * 查询正在运行的实例
     */
    @Test
    public void queryExecution(){
        List<Execution> executionList = runtimeService.createExecutionQuery()  //创建正在执行的流程查询对象
                      .processDefinitionKey("activiti_leave")   //根据流程定义的key查询
                      .orderByProcessInstanceId()  //根据流程实例id排序
                      .desc()  //倒序
                      .list();  //查询出集合
        for(Execution execution: executionList){
            System.out.println("正在执行的流程对象的id: "+execution.getId());
            System.out.println("所属流程实例的id:"+execution.getProcessInstanceId());
            System.out.println("正在活动的节点的id: "+execution.getActivityId());
        }
    }

3 查询任务

测试代码:

/**
     * 根据办理人查询任务
     */
    @Test
    public void queryTaskByAssignee(){
        String assignee = "employee";
        List<Task> taskList = taskService.createTaskQuery()
                                     .processDefinitionKey("activiti_leave")
                                     .taskAssignee(assignee)
                                     .orderByTaskCreateTime()
                                     .desc()
                                     .list();
        
        for(Task task: taskList){
            System.out.println("任务id: "+task.getId());
            System.out.println("任务名字: "+task.getName());
            System.out.println("任务创建时间: "+task.getCreateTime());
            System.out.println("办理人: "+task.getAssignee());
        }
    }

4 查询任务位置

测试代码:

/**
     * 查询当前流程实例状态
     */
    @Test
    public void queryProInstanceStateByProInstanceId(){
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId("35001").singleResult();
        if(processInstance == null){
            System.out.println("当前流程已经完成");
        }else{
            System.out.println("当前流程实例ID："+processInstance.getId());
            System.out.println("当前流程所处的位置："+processInstance.getActivityId());
        }
    }

5 完成任务

测试代码:

/**
     * 根据办理人查询任务
     */
    @Test
    public void queryTaskByAssignee(){
        String assignee = "employee";
        List<Task> taskList = taskService.createTaskQuery()
                                     .processDefinitionKey("activiti_leave")
                                     .taskAssignee(assignee)
                                     .orderByTaskCreateTime()
                                     .desc()
                                     .list();
        
        for(Task task: taskList){
            System.out.println("任务id: "+task.getId());
            System.out.println("任务名字: "+task.getName());
            System.out.println("任务创建时间: "+task.getCreateTime());
            System.out.println("办理人: "+task.getAssignee());
        }
    }

Activiti系列回顾:

Activiti工作流之简介与环境搭建

Activiti工作流之流程部署和相关操作

分配甲、乙、丙、丁四人去完成五项任务，每人完成各项任务的时间如下表所示。由于任务数多于人数，故规定其中有一个人可完成两项任务，其余三人每人只完成一项任务。试确定总花费时间最少的分配任务方案。（只建立模型，不必求解)

建立模型：
解法一：暴力搜索
数据规模较小，可以暴搜求解。

#include <bits/stdc++.h>

using namespace std;
int a[5][6] = {{0, 0,  0,  0,  0,  0},
               {0, 9,  2,  4,  15, 9},
               {0, 6,  5,  12, 4,  2},
               {0, 11, 7,  13, 4,  17},
               {0, 19, 11, 15, 8,  9}};
bool v[10];
map<int, string> mp;
struct sta {
    int sum, two;
    pair<int, int> c;
    vector<pair<int, int> > one;
};
vector<sta> sch;

void dfs(int u, sta now) {
    if (u == 5) {
        if (!sch.empty() && sch.back().sum > now.sum)sch.clear();
        if (sch.empty() || sch.back().sum == now.sum)
            sch.push_back(now);
        return;
    }
    if (!sch.empty() && sch.back().sum < now.sum)return;
    vector<int> c;
    for (int i = 1; i <= 5; i++)if (!v[i])c.push_back(i);
    if (u == 4 && c.size() == 2) {
        v[c[0]] = true, v[c[1]] = true;
        sta nex = now;
        nex.two = u;
        nex.sum += a[u][c[0]] + a[u][c[1]];
        nex.c = make_pair(c[0], c[1]);
        dfs(u + 1, nex);
        v[c[0]] = false, v[c[1]] = false;
        return;
    }
    for (int i = 0; i < c.size(); i++) {
        sta nex = now;
        nex.sum += a[u][c[i]];
        nex.one.emplace_back(u, c[i]);
        v[c[i]] = true;
        dfs(u + 1, nex);
        v[c[i]] = false;
    }
    for (int i = 0; i < c.size(); i++)
        for (int j = i + 1; j < c.size(); j++) {
            v[c[i]] = true, v[c[j]] = true;
            sta nex = now;
            nex.two = u;
            nex.sum += a[u][c[i]] + a[u][c[j]];
            nex.c = make_pair(c[i], c[j]);
            dfs(u + 1, nex);
            v[c[i]] = false, v[c[j]] = false;
        }
}

int main() {
    sta now = {0, 0, {0, 0}, {}};
    dfs(1, now);
    mp[1] = "甲", mp[2] = "乙", mp[3] = "丙", mp[4] = "丁";
    printf("总最小花费时间为：%d\n", sch.back().sum);
    for (int i = 0; i < sch.size(); i++) {
        cout << "方案" << i + 1 << ":" << endl;
        cout << mp[sch[i].two] << "完成任务：" << (char) ('A' + sch[i].c.first - 1) << "和"
             << (char) ('A' + sch[i].c.second - 1) << endl;
        for (int j = 0; j < sch[i].one.size(); j++) {
            cout << mp[sch[i].one[j].first] << "完成任务：" << (char) ('A' + sch[i].one[j].second - 1) << endl;
        }
        puts("");
    }
    return 0;
}

总最小花费时间为：25
方案1:
甲完成任务：B和C
乙完成任务：A
丙完成任务：D
丁完成任务：E

解法二：费用流
建图方式如下图，跑最小费用最大流即可。

#include<bits/stdc++.h>

using namespace std;
const int N = 20, M = 200;

struct EK {
    int s, t, head[N], ver[M], Next[M], tot = 1, pre[N];
    int mxf, ans, edge[M], c[M], d[N], h[N], n;

    inline void add(int x, int y, int z, int w) {
        n = max({n, x, y});
        ver[++tot] = y, Next[tot] = head[x], edge[tot] = z, c[tot] = w, head[x] = tot;
        ver[++tot] = x, Next[tot] = head[y], edge[tot] = 0, c[tot] = -w, head[y] = tot;
    }

    priority_queue<pair<int, int> > q;

    inline bool dijkstra() {
        memset(d, 0x3f, sizeof(int) * (n + 1));
        while (!q.empty())q.pop();
        q.push({0, s}), d[s] = 0;
        while (!q.empty()) {
            pair<int, int> u = q.top();
            q.pop();
            if (d[u.second] < -u.first)continue;
            for (int i = head[u.second]; i; i = Next[i]) {
                int y = ver[i], z = edge[i], w = c[i];
                if (!z || d[y] <= d[u.second] + w + h[u.second] - h[y]) continue;
                d[y] = d[u.second] + w + h[u.second] - h[y], pre[y] = i;
                q.push({-d[y], y});
            }
        }
        return d[t] != 0x3f3f3f3f;
    }

    inline void upd() {
        for (int i = 0; i <= n; i++)h[i] += d[i];
        int x = t, now = 0x3f3f3f3f;
        while (x != s)now = min(now, edge[pre[x]]), x = ver[pre[x] ^ 1];
        mxf += now, ans += now * h[t];
        x = t;
        while (x != s)
            edge[pre[x]] -= now, edge[pre[x] ^ 1] += now, x = ver[pre[x] ^ 1];
    }

    inline int solve() {
        while (dijkstra())upd();
        return ans;
    }

    inline void init() {
        memset(head, 0, sizeof(int) * (n + 1));
        memset(h, 0, sizeof(int) * (n + 1));
        tot = 1, mxf = ans = n = 0;
    }
} E;

int a[5][6] = {{0, 0,  0,  0,  0,  0},
               {0, 9,  2,  4,  15, 9},
               {0, 6,  5,  12, 4,  2},
               {0, 11, 7,  13, 4,  17},
               {0, 19, 11, 15, 8,  9}};
vector<int> e[5][2];
vector<int> ans[5];
map<int, string> mp;

int main() {
    E.s = 0, E.t = 15;
    E.add(E.s, 5, 1, 0);
    for (int i = 1; i <= 4; ++i) {
        E.add(E.s, i, 1, 0);
        E.add(5, 5 + i, 1, 0);
    }
    for (int i = 1; i <= 4; ++i)
        for (int j = 1; j <= 5; ++j) {
            E.add(i, j + 9, 1, a[i][j]);
            e[i][0].push_back(E.tot);
            E.add(i + 5, j + 9, 1, a[i][j]);
            e[i][1].push_back(E.tot);
        }
    for (int i = 10; i <= 14; ++i)E.add(i, E.t, 1, 0);
    E.solve();
    bool flag = false;
    for (int i = 1; i <= 4; ++i) {
        for (int j:e[i][0])
            if (!E.edge[j ^ 1]) {
                ans[E.ver[j]].push_back(E.ver[j ^ 1] - 9);
                break;
            }
        if (!flag)
            for (int j:e[i][1])
                if (!E.edge[j ^ 1]) {
                    flag = true, ans[E.ver[j] - 5].push_back(E.ver[j ^ 1] - 9);
                    break;
                }
    }
    mp[1] = "甲", mp[2] = "乙", mp[3] = "丙", mp[4] = "丁";
    printf("总最小花费时间为：%d\n", E.ans);
    for (int i = 1; i <= 4; ++i) {
        if (ans[i].size() == 2)
            cout << mp[i] << "完成任务：" << (char) ('A' + ans[i][0] - 1) << "和"
                 << (char) ('A' + ans[i][1] - 1) << endl;
        else
            cout << mp[i] << "完成任务：" << (char) ('A' + ans[i][0] - 1) << endl;
    }
    return 0;
}

总最小花费时间为：25
甲完成任务：C和B
乙完成任务：A
丙完成任务：D
丁完成任务：E