CC BY
21
UDC 004.4-004.9
PRIHOZHY АА.
EXACT AND GREEDY ALGORITHMS OF ALLOCATING EXPERTS TO MAXIMUM
SET OF PROGRAMMER TEAMS
Belarusian National Technical University
The allocation of experts to programmer teams, which meet constraints on professional competences relat-ed to programming technologies, languages and tools an IT project specifies is a hard combinatorial problem. This paper solves the problem of forming the maximum number of teams whose experts meet all the constraints within each team. It develops and compares two algorithms: a heuristic greedy and exact optimal. The greedy algorithm iteratively solves the set cover problem on a matrix of expert competences until can create the next workable team of remaining experts. The paper proves that the allocation greedy algorithm is not accurate even if the set cover algorithm is exact. We call the allo-cation algorithm as double greedy if the set cover algorithm is greedy. The exact algorithm we propose finds optimal solution in three steps: generating a set of all non-redundant teams, producing a graph of team's independency, and searching for a maximum clique in the graph. The algorithm of generating the non-redundant teams traverses a search tree con-structed in such a way as to guarantee the creation of all non-redundant teams and absorbing all redundant teams. The edges of the non-redundant team independency graph connect teams that have no common expert. The maximum clique search algorithm we propose accounts for the problem and graph features. Experimental results show that the exact algo-rithm is a reference one, and the double-greedy algorithm is very fast and can yield suboptimal solutions for large-size allocation problems.
Keywords: programmer, team, competence, expert, allocation problem, optimization.
Introduction
In the rapidly developing information technology industries, there is need to assemble teams of growing complexity to tackle problems on a larger scale than ever before. Agile is a set of values and principles of developing software and finding solutions over joint efforts of development teams and customers [1, 2]. Agent-based evolutionary optimization methods [3] aim at performing the management of teams.
The process of allocating tasks to teams has not received much attention. In [4], the authors describe the process of task allocation as including three mechanisms of workflow across teams and five types of task allocation strategies. In [5], the authors emphasize that a successful software development team has to be made up of competent developers. Competency is the ability of a developer to perform a job properly. It is a combination of knowledge, skills and attitudes used to improve performance. In [6-8], the authors proposed platforms that increase team's productivity and efficiency for various tasks and projects. In [9], a method for formalizing and evaluating the competency of individual programmers and entire programmer teams was proposed. Since the programmer allocation problem is combinatorial, the goal of works [10 - 12] was to develop a genetic-algorithm-based meta-heuristic approach for finding acceptable solutions of large-size problems at different requirements to competences of programmers.
In the paper, we formulate a combinatorial problem and propose a heuristic greedy and an exact optimal algorithm of allocating experts to a maximum set of programmer teams, assuming that two teams may not share the same expert. The contribution of the paper is as follows:
1. An algorithm of generating feasible non-redundant teams of experts is proposed;
2. A graph of non-redundant teams independency is introduced; the experts allocation problem is solved by searching for a maximum clique in the graph;
3. The experimental results obtained show that the heuristic greedy algorithm is very fast and gives good enough solutions against the exact algorithm.
Combinatorial problem formulation
Let C = {cp..., cm} be a set of competences Joseph Sijin proposed in [13] in order to create the programmer competency matrix and to estimate the qualification of candidates to IT projects. He introduced four predefined competency levels L0, L1, L2 and L3, and formulated requirements for each of them regarding all the competences.
Let P = {p1,.pn} be a set of programmers who desire to work on an IT project and have evaluated the competency level on each of the topics. Table 1 describes a sample of 12 programmers characterized by 12 competences. It indicates the competency Level(p, c) of each programmerp for each competence c.
Usually, each IT project establishes a constraint Level(p, c) > 1c for the level of each competence c e C at least one programmer p of the team must have. We also use notation l for the overall competence: 1c = l for all c e C.
Table 1. Competence level of twelve programmers (case study)
Program mer Competence
0 1 2 3 4 5 6 7 8 9 10 И
0 3 0 3 3 3 2 2 3 0 3 0 2
1 3 1 2 0 1 1 3 2 3 3 0 3
2 3 2 3 3 0 1 1 0 0 2 3 3
3 1 2 1 0 2 3 0 2 0 3 3 2
4 1 3 1 3 3 3 0 2 1 3 0 2
5 3 3 3 2 0 1 3 1 3 2 1 1
6 1 1 0 2 2 3 3 2 3 1 1 2
7 0 3 2 0 0 2 2 1 2 1 2 2
8 1 3 2 0 3 0 2 0 2 0 1 0
9 1 1 0 2 0 1 3 0 1 3 2 2
10 0 2 1 0 0 2 3 0 1 2 1 0
И 1 3 0 0 0 0 2 1 1 3 3 0
Table 2. Matrix A of expert competences at X > LI (case study)
Expert Competence
0 1 2 3 4 5 6 7 8 9 10 11
0 + + + + + + + + +
1 + + + + + + +
2 + + + + + + +
3 + + + + + + +
4 + + + + + + +
5 + + + + + + +
6 + + + + + + +
7 + + + + + + +
8 + + + + +
9 + + + + +
10 + + + +
11 + + + +
We qualify a programmer who meets the constraint on at least one competence as expert. The working team must have an expert for each competence. Applying the constraint of l = L2 to Table 1 generates Table 2, which describes a matrix A[nxm] of expert competences. Symbol '+' indicates competences the experts have.
De finition 1. A team t is a subset of programmers t e P such
that
uA.=C
pet
(1)
Definition 2. A team s is redundant if at least one programmer r e s exists such that team t = s \ {r} meets (1).
Definition 3. A team t is non-redundant if for any programmer r e t inequality (2) holds.
U
pa\{r)
A.,
(2)
max I T I
7efi
(3)
subject to
A is a set of competences of expert p. Equation (5) estimates
an upper bound of the team count.
rithm [15]. In this case, Algorithm 1 becomes the double-greedy heuristic algorithm.
Table 3. The matrix A proves that greedy algorithm can give suboptimal solution
Definition 4. A team t absorbs team e if tee. Definition 5. Teams t. and t. are independent if t. nt = 0.
Let W be a set of feasible allocations of experts of P to a set T of workable teams, assuming that size |T | is not defined in advance. Our objective is to solve the following combinatorial problem:
Expert Competence
Co Cl C2 C3 C4
Po + + +
Pi + + +
pi +
pi +
P4 +
P5 +
to= {p0,p\} ti= {pa,p2,pi} h= {p\,PA,Ps}
a)
©
b)
(5)
where Spc = 1 if Apc = '+'. According to Table 2, upper(\T) = 4. Greedy algorithm of solving the problem
The greedy Algorithm 1 we propose heuristical-ly allocates experts to teams and finds a subopti-mal solution in general case. The algorithm itera-tively solve the well-known set cover problem [14], which is NP-complete, until the next worka-ble team cannot be created of the remaining ex-perts. Initially set R consists of all experts of set P, and set T of teams is empty. Each iteration of the loop forms a team of minimum size, which covers all competences, by solving the set cover problem. Then it removes experts of team from R and add the team to T. If team is empty, the algorithm ter-minates its operation.
Algorithm 1: Greedy allocation of experts to teams
Input: A set P of experts
Input: A set C of competences
Input: A matrix A of expert competences
Output: A set J of workable teams represented by subsets of experts R P 0 next team true
while next_team do
team <— SetCoverProblem (C, R, A) if team = 0 then
next team «— false
else
T<- Tu { team } R-<^R\team
return T
Figure 1 - Non-redundant teams of experts from Table 3: a) team members; b) team independency graph Gb
Generation of feasible non-redundant teams
A team search tree depicted in Figure 2 is a directed labeled acyclic graph supporting the generation of redundant and all non-redundant workable teams. All nonterminal vertices (without fill) of the tree correspond to programmers. There are four types of terminal vertex: a redundant workable team (in red); a non-redundant team (in green); a non-workable team which does not cover all competencies of C (in black); and a tree's branch represented as single vertex (in grey). There are two types of edge in the tree: on-edge (right outgoing solid line) and off-edge (left outgoing dash line). A path from root to a leaf tk determines the team members. If the path includes an outgoing on-edge of vertexp. thenp. e tk, if it includes an off-edge then p. e tk.
Algorithm 1 does not guarantee obtaining the accurate solution. Table 3 describes matrix A, which proves the assertion. Figure 1a shows three non-redundant teams that can be generated from A. Algorithm 1 selects team t0 at the first iteration and returns T = {t0} after the second iteration. Figure 1b shows that the maximum-size solution is T = {tj, t2}, which represents a maximum clique of a team independency graph GD. As Algorithm 1 is a heuristic one, it is reasonable to solve the set cover problem by the greedy algorithm [15]. In this case, Algorithm 1 becomes the double-greedy heuristic algorithm.
Algorithm 1 does not guarantee obtaining the accurate solution. Table 3 describes matrix A, which proves the assertion. Figure 1a shows three non-redundant teams that can be generated from A. Algorithm 1 selects team t0 at the first iteration and returns T = {t0} after the second iteration. Figure 1b shows that the maximum-size solution is T = {t1, t2}, which represents a maximum clique of a team independency graph GD. As Algorithm 1 is a heuristic one, it is reasonable to solve the set cover problem by the greedy algo-
Figure 2 - Non-redundant teams search tree
Algorithm 2 uses four operation modes: FORWARD, BACKWARD, SUCCESS, and FAILURE. In mode FORWARD, it switches to mode SUCCESS if the programmers collected in stack SS have set C of competences. If the depth of stack SM is equal to n, the mode switches to FAILURE. Otherwise, the algorithm keeps the mode, pushes the topm programmer in stack SS adding programmer's competences to the current team, and passes from programmer topm to programmer topm + 1 through on-edge. In mode SUCCESS, the algorithm gener-ates new team, possibly absorbs the previously created teams of set T, adds the new team to T, and switches to mode BACKWARD. In BACKWARD, the algorithm performs backtracking while SM has off-edge at top. If the depth is equal to 0, the algo-rithm terminates operation returning T. If a record with on-edge found, the algorithm replaces it with off-edge and switches to the FORWARD mode.
Algorithm 2: Generation of nun-redundant teams
Output: A set 7*of non-redundant teams represented by expert subsets
In mode FORWARD, the algorithm switches to FAILURE, if it has generated an unworkable team passing through on-edges. In mode FAILURE, it performs backtracking over on-edges using both stacks to find a vertex, which allows the traversal of alternative paths in the search tree and allows the generation of alternative teams in the FORWARD mode.
The search tree generated by Algorithm 2 is de-picted in Figure 2. Totally, the tree includes 237 terminal team-vertices that represent 190 redun-dant (in red) and 47 non-redundant (in green) teams. The figure shows only part of generated branches, grey leafs represent tree branches con-taining other teams.
A path from tree root to team-leaf determines the team members. For instance, the path to t9 includes nonterminal vertices 0,.,7. Vertices 0, 1, 4, 5 and 7 have outgoing on-edges (solid line). Vertices 2, 3 and 6 have outgoing off-edges (dash line). Therefore,
t9 = p p^ ^ P^ P7}.
In the search tree, dot-line edges show absorbing one team by other team. For example, team t9 has outgoing dot-line edge pointing to team t2 = {p0, p1, p4, p5, p6, p7}. Therefore, t9 absorbs t2 because i(ci,.
The search tree has properties as follows:
1. In any path from root to leaf, the competences of predecessors does not include all competences of successors.
2. The competences of successors may completely include the competences of a predecessor.
3. As a result, a team may only absorb other redundant team located to right in the search tree.
4. Algorithm 2 finds all non-redundant teams for the given set of programmers and absorbs all redundant teams.
Figure 3 depicts a set of 47 non-redundant teams Algorithm 2
has generated over the tree from Figure 2. The rows correspond to teams, and the columns correspond to programmers. Value 1 indicates including a pro-grammer in a team.
Exact algorithm based on non-redundant team independency graph
In the undirected non-redundant team independency graph GD = (T,D), T is a set of non-redundant teams, and D is a set of edges (¿, t) such that int=0. Figure 4 depicts an adjacency matrix of Hie graph generatei for teams from Figure 3.
To allocate exactly experts to maximum number of teams, we find the maximum clique of graph GD. Algorithm 3 we propose takes into account the graph features. Its inputs are matrix A and graph Gd, and its output is a maximum set Allocate of independent teams. It calculates an upper bound of the set size using (5) and calculates a lower bound by running the greedy Algorithm 1. Then, it orders the graph vertices by vertex power descending, and modifies GD to G'D.
Algorithm 3: Search for maximum clique in non-redundant team independency graph
Input: A matrix A of expert competences
Input: A graph Ga = (T, D) of independency of non-redundant teams Output: A subset Allocate c T of independent teams representing problem solution UpperBond Equations (A) LowerBound GreedyAlgorithm (GD) T <T- Ordering (I) G'd <- Modifying (GD, T) Allocate 4—LowerBound if ¡LowerBound| = | UpperBond] then return Allocate
else
for CliqueSize \LowerBound{ + 1 to \UpperBond\ (lu G 'D GenerateSubgraph (G'd . CliqueSize) Clique SearchClique (G "D, CliqueSize) ir Clique = 0 then return Allocate
else
Allocate Clique return Allocate
Algorithm 4: Search for clique of required size in sub-graph
Input: A sub-graph G'„ = IT'. D") Input: A required size CliqueSize of clique Output: A subset Clique c T' of required size for i Ito |7"| do if in - i < CliqueSize then return 0
else
Stack(0).team ft Stack(0).count 1 Stack(0).neighbours neighbourhood^,) top 1 while top > 0 do
if top = CliqueSize then
return GenerateClique(Stack) if Stack(top-l).count > \Stack{top—l). neighbours] then top <— top — 1 if top >0 then
Stack{top-\).count Stack(top-i).count + 1 continue
nb Stack( top— 1). neighbours(Stack{top-1) count) flag true for j 0 to top-1 do
if nb £ Stack(f).neighbours then flag <—false break it flag then
The algorithm checks the equality of the lower and upper bounds and returns Allocate as optimum. Otherwise, it organizes a loop to find the largest team size from \LowerBound\ + 1 to UpperBond]. To speed up the search, function GenerateSubgraph reduces G'd to G"d of smaller size, CliqueSize, and function Search-Clique finds a required clique.
Algorithm 4 searches for a clique of the required CliqueSize in sub-graph G"d. It forms the clique by selecting a vertex from 1 to \T"\-CliqueSize+1 and adding other mutually adjacent vertices. To perform combinatorial search, it uses a Stack. All vertices pushed in the Stack are mutually connected. When the stack depth reaches CliqueSize the search is over and the clique is extracted from the stack. Otherwise, the algorithm checks if it has visited all neighbors of the vertex assigned to record top - 1. If yes, it pops the top record and returns to the previous vertex. If no, it passes to the next neighbor nb. If nb is adjacent to all previous vertices in the Stack, the algorithm pushes nb in the next record and repeats the described steps.
In Figure 4, the filled four rows and four columns describe the maximum clique that represents an optimal solution including four
teams as foll°ws: ¿13 = p p7} i30 = p pe p^ pM} i38 = p pA, p8}
2nd ¿40 = p P5}.
Figure 3 - Non-redundant teams of experts from Table 2
Figure 4 - Adjacency matrix of non-redundant teams independency graph GD
Experimental results
We have developed a computer program that implements both the greedy and exact algorithms of allocating experts to teams. Table 4 reports experimental results obtained on six runs of the program on various expert samples of 20 programmers and 20 competences. The samples differ by minimum (upper bound of teams count) and average number of competences per expert (third and fourth parameters in the table). The increase of upper bound from 4 to 14 causes the growth of the maximum team count (exact solution) from 4 to 10, the greedy lower bound from 3 to 9, the competence count per expert from 5.8 to 15.8. The difference between the upper bound and the
Table 4. Experimental results of allocating 20 experts to pro-
grammer teams for 20 competences and various matrix A
Parameter Run
1 2 3 4 5 6
Greedy lower bound 3 5 4 6 8 9
Maximum team count 4 5 6 7 9 10
Upper bound 4 6 8 10 12 14
Competences per expert 5.8 7.6 10.0 12.0 13.8 15.8
Non-redundant teams 665 930 857 513 377 204
All teams (times) 70.8 23.8 18.5 14.9 6.2 3.5
optimal solution has increased from 0 (run 1) to 4 (run 6).The greedy solution is one team less on average, although it is optimal for run 2. The number of generated non-redundant teams has increased from 665 to 930 and then has decreased to 204. The number of all teams (redundant and non-redundant) has been larger over the number of non-redundant teams by 70.8 downto 3.5 times.
Conclusion
The paper has formulated a combinatorial problem of allocating experts to maximum set of programmer teams accounting for professional competences. In our work, to tackle the problem we have developed two algorithms: greedy heuristic and exact optimal. The first algorithm is fast and solves the problem using set cover problem solutions. Although the second algorithm is slow, it is a criterion for the evaluation of heuristic algorithm quality. The developed software allocates experts to teams and allows for obtaining experimental results on various-size input data. The fast double-greedy algorithm slightly loses to the exact algorithm by quality, but is applicable to large-size combinatorial problems.
REFERENCES
1. Joshi, S. Agile Development - Working with Agile in a Distributed Team Environment / S. Joshi // MSDN Magazine, 2012, Vol.27, No.1, pp.1-6.
2. Collier, K.W., Agile Analytics: A Value-Driven Approach to Business Intelligence and Data Warehousing. - Pearson Education, 2012. - 74 p.
3. Muller, J.P., Rao, A.S., Singh, M.P. A Teams: An Agent Architecture for Optimization and Decision-Support, Proceedings 5th International Workshop, ATAL'98 Paris, France, July 4-7, 1998, pp. 261-276.
4. Masood Z., Hoda R., Blincoe K. (2017) Exploring Workflow Mechanisms and Task Allocation Strategies in Agile Software Teams. In: Baumeister H., Lichter H., Riebisch M. (eds) Agile Processes in Software Engineering and Extreme Programming. XP 2017. Lecture Notes in Business Information Processing, vol 283. Springer, Cham. https://doi.org/10.1007/978-3-319-57633-6_19.
5. R. Britto, P. S. Neto, R. Rabelo, W. Ayala and T. Soares, "A hybrid approach to solve the agile team allocation problem," 2012 IEEE Congress on Evolutionary Computation, 2012, pp. 1-8, doi: 10.1109/CEC.2012.6252999.
СИСТЕМНЫЙ анализ и прикладная информатика
1, 2022
6. Wrike [Электронный ресурс] - Режим доступа: https://www.wrike.com/, - Загл. с экрана - Яз. англ. Дата доступа -28.10.2021.
7. Flow [Электронный ресурс] - Режим доступа: https://www.getflow.com/, - Загл. с экрана - Яз. англ. Дата доступа -
28.10.201
8. Gutirrez, J. H., Astudillo, C. A., Ballesteros-P?rez, P., Mora-Meli?, D. and Candia-V?jar, A. (2016) The multiple team formation problem using sociometry. Computers and Operations Research, 75. pp. 150-162. ISSN 0305-0548 doi: https://doi. org/10.1016/j.cor.2016.05.012
9. Barricelli, N.A Symbio genetic evolution processes realized by artificial methods / N.A. Barricelli // Methodos, 1957, pp.
143-182.
10. Prihozhy AA, Zhdanouski AM Method of qualification estimation and optimization of professional teams of programmers. «System analysis and applied information science». - 2018, No. 2, pages 4-11. https://doi.org/10.21122/2309-4923-2018-2-4-11
11. Prihozhy, A. Genetic algorithm of optimizing the size, staff and number of professional teams of programmers / A. Prihozhy, A. Zhdanouski // Open Semantic Technologies for Intelligent Systems. - Minsk, BSUIR, 2019. - P. 305-310.
12. Prihozhy AA, Zhdanouski A.M Genetic algorithm of optimizing the qualification of programmer teams. System analysis and applied information science. - 2020, No. 4, pages 31-38. https://doi.org/10.21122/2309-4923-2020-4-31-38
13. Sijin, J. Perspectives on Software, Technology and Business: Programmer Competency Matrix / J. Sijin // [Electronic resource]. -Mode of access: https://sijinjoseph.com/programmer-competency-matrix/. - Date of access: 28.10.2021.
14. Karp R.M (1972) Reducibility among Combinatorial Problems. In: Miller R.E., Thatcher J.W., Bohlinger J.D. (eds) Complexity of Computer Computations. The IBM Research Symposia Series. Springer, Boston, MA. https://doi.org/10.1007/978-1-4684-2001-2_9
15. Prihozhy, AA Asynchronous scheduling and allocation / A.A. Prihozhy / Proceedings Design, Automation and Test in Europe. Paris, France. - IEEE, 1998, pp. 963-964.
16. A. Prihozhy, S. Casale-Brunet, E. Bezati and M Mattavelli. "Efficient Dynamic Optimization Heuristics for Dataflow Pipelines," IEEE International Workshop on Signal Processing Systems, IEEE, pp. 337- 342, October 2018.
17. Prihozhy, A., Casale-Brunet, S., Bezati, E., M Mattavelli. Pipeline Synthesis and Optimization from Branched Feedback Dataflow Programs. Journal of Signal Processing Systems, Springer Nature, 2020, Vol. 92, pages 1091-1099 https://doi.org/10.1007/ s11265-020-01568-5.
ЛИТЕРАТУРА
1. Joshi, S. Agile Development - Working with Agile in a Distributed Team Environment / S. Joshi // MSDN Maga-zine, 2012. Vol.27, No.1, pp.1-6.
2. Collier, K.W., Agile Analytics: A Value-Driven Approach to Business Intelligence and Data Warehousing. - Pearson Education, 2012. - 74 p.
3. Muller, J.P., Rao, AS., Singh, M.P. A Teams: An Agent Architecture for Optimization and Decision-Support, Pro-ceedings 5th International Workshop, ATAL'98 Paris, France, July 4-7, 1998, pp. 261-276.
4. Masood Z., Hoda R., Blincoe K. (2017) Exploring Workflow Mechanisms and TaskAllocation Strategies in Agile Software Teams. In: Baumeister H., Lichter H., Riebisch M. (eds) Agile Processes in Software Engineering and Ex-treme Programming. XP 2017. Lecture Notes in Business Information Processing, vol 283. Springer, Cham. https://doi.org/10.1007/978-3-319-57633-6_19
5. R. Britto, P. S. Neto, R. Rabelo, W. Ayala and T. Soares, «A hybrid approach to solve the agile team allocation problem,» 2012 IEEE Congress on Evolutionary Computation, 2012, pp. 1-8, doi: 10.1109/CEC.2012.6252999.
6. Wrike [Электронный ресурс] - Режим доступа: https://www.wrike.com/, - Загл. с экрана - Яз. англ. Дата доступа -28.10.2021.
7. Flow [Электронный ресурс] - Режим доступа: https://www.getflow.com/, - Загл. с экрана - Яз. англ. Дата досту-па -28.10.2021
8. Gutirrez, J. H., Astudillo, C. A., Ballesteros-P?rez, P., Mora-Meli?, D. and Candia-V?jar, A. (2016) The multiple team formation problem using sociometry. Computers and Operations Research, 75. pp. 150-162. ISSN 0305-0548 doi: https://doi. org/10.1016/j.cor.2016.05.012
9. Barricelli, N.A. Symbio genetic evolution processes realized by artificial methods / N.A. Barricelli // Methodos, 1957, pp.
143-182.
10. Прихожий AA, Ждановский АМ Метод оценки квалификации и оптимизация состава профессиональных групп программистов. «Системный анализ и прикладная информатика». - 2018, № 2, с. 4-11. https://doi.org/10.21122/2309-4923-2018-2-4-11
11. Prihozhy, A. Genetic algorithm of optimizing the size, staff and number of professional teams of programmers / A. Prihozhy, A. Zhdanouski // Open Semantic Technologies for Intelligent Systems. - Minsk, BSUIR, 2019. - P. 305-310.
12. Prihozhy AA, Zhdanouski A.M Genetic algorithm of optimizing the qualification of programmer teams. System analysis and applied information science. - 2020, No. 4, pages 31-38. https://doi.org/10.21122/2309-4923-2020-4-31-38
13. Sijin, J. Perspectives on Software, Technology and Business: Programmer Competency Matrix / J. Sijin // [Electronic resource]. -Mode of access: https://sijinjoseph.com/programmer-competency-matrix/. - Date of access: 28.10.2021.
14. Karp R.M. (1972) Reducibility among Combinatorial Problems. In: Miller R.E., Thatcher J.W., Bohlinger J.D. (eds) Complexity of Computer Computations. The IBM Research Symposia Series. Springer, Boston, MA. https://doi.org/10.1007/978-1-4684-2001-2_9.
15. Prihozhy, A.A. Asynchronous scheduling and allocation / A.A. Prihozhy / Proceedings Design, Automation and Test in Europe. Paris, France. - IEEE, 1998, pp. 963-964.
16. A. Prihozhy, S. Casale-Brunet, E. Bezati and M Mattavelli. "Efficient Dynamic Optimization Heuristics for Dataflow Pipelines," IEEE International Workshop on Signal Processing Systems, IEEE, pp. 337- 342, October 2018.
17. Prihozhy, A., Casale-Brunet, S., Bezati, E., M Mattavelli. Pipeline Synthesis and Optimization from Branched Feedback Dataflow Programs. Journal of Signal Processing Systems, Springer Nature, 2020, Vol. 92, pages 1091-1099 https://doi.org/10.1007/ s11265-020-01568-5.
Прихожий А.А.
ТОЧНЫЙ И ЖАДНЫЙ АЛГОРИТМЫ РАСПРЕДЕЛЕНИЯ ЭКСПЕРТОВ НА МАКСИМАЛЬНОМ МНОЖЕСТВЕ ГРУПП ПРОГРАММИСТОВ
Белорусский национальный технический университет
Распределение экспертов по программистским группам, отвечающее требованиям профессио-нальной компетенции в сфере программирования, специфицированным в ИТ-проекте, является сложной комбина-торной проблемой. В данной работе решается задача формирования максимального числа групп с включением в них экспертов, обеспечивающих выполнение каждой группой требований к компетенциям. В статье разрабаты-ваются и сравниваются два алгоритма решения задачи: эвристический жадный и точный оптимальный. Жадный алгоритм итеративно решает задачу о покрытии на матрице экспертных компетенций до тех пор, пока не смо-жет создать работоспособную группу из оставшихся экспертов. В статье доказано, что этот алгоритм не оп-тимален, даже если задача о покрытии решается оптимально. Алгоритм назначения экспертов является дважды жадным, если он использует жадный алгоритм покрытия множества. Предлагаемый точный алгоритм находит оптимальное решение на трех шагах: создание набора всех не избыточных групп, построение графа независимости групп и поиск максимальной клики графа. Алгоритм генерации групп обходит дерево поиска, построенное так, чтобы гарантировать нахождение всех не избыточных групп и поглощение всех избыточных групп. Ребра графа независимости групп соединяют вершины-группы, не имеющие общих экспертов. В статье предложен алгоритм поиска максимальной клики, учитывающий особенности графа и решаемой задачи. Экспериментальные результа-ты показывают, что точный алгоритм является оптимальным эталонным, а алгоритм двойной жадности явля-ется быстрым и может давать решение
Anatoly Prihozhy, received his Diploma of Electrical Engineering from the State Polytechnic, Minsk, Belarus in 1975, his PhD degree in computer-aided design from the National Academy of Sciences Minsk, Belarus in 1984, and his Doctor Habilitation degree in computer science from Ukraine, Kyiv and Belarus, Minsk in 1999. He was Visiting Professor at the Swiss Federal Institute of Technology, Lausanne, Switzerland in 2001, 2004, 2010 and 2013, 2015 and 2016 and at the Freiburg University, Germany in 2000. He is currently full professor at Computer and System Software Department of the Belarusian National Technical University. He has several books and more than 300 publications in Eastern and Western Europe, USA and Canada His research interests include programming, hardware and system description languages, compilers and tools, system-, high- and logic-level computer aided design and optimization of parallel and incompletely specified digital systems.
