260416_06_ENH: 1차 완성 - 위원 센터 동시 고려

This commit is contained in:
2026-04-16 18:28:53 +09:00
parent ac8401061f
commit 51a2712066
9 changed files with 864 additions and 381 deletions

View File

@@ -53,6 +53,8 @@ public class PairingProperties {
private long preferenceBaseWeight = 10_000L; private long preferenceBaseWeight = 10_000L;
private long preferenceRankPenalty = 100L; private long preferenceRankPenalty = 100L;
private long residenceMatchWeight = 1_000L; private long residenceMatchWeight = 1_000L;
private long usedMemberWeight = 300_000L;
private long memberBalanceWeight = 1_000L;
} }
@Getter @Getter
@@ -61,6 +63,7 @@ public class PairingProperties {
private int maxDispatchRegionsPerPair = 5; private int maxDispatchRegionsPerPair = 5;
private int maxAssignmentsPerCenter = 30; private int maxAssignmentsPerCenter = 30;
private int maxAssignmentsPerMember = 80; private int maxAssignmentsPerMember = 80;
private int maxDatesPerAssignmentCandidate = 5;
} }
@Getter @Getter

View File

@@ -1,6 +1,5 @@
package com.kri.p6.ncrc.pairing.service; package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.common.enums.ExperienceType;
import com.kri.p6.ncrc.pairing.common.enums.Gender; import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.common.enums.MemberRole; import com.kri.p6.ncrc.pairing.common.enums.MemberRole;
import com.kri.p6.ncrc.pairing.config.PairingProperties; import com.kri.p6.ncrc.pairing.config.PairingProperties;
@@ -40,9 +39,12 @@ public class PairingCandidateService {
List<DispatchRegionCandidate> dispatchRegionCandidates = trimDispatchRegionCandidates( List<DispatchRegionCandidate> dispatchRegionCandidates = trimDispatchRegionCandidates(
createDispatchRegionCandidates(data, pairCandidates)); createDispatchRegionCandidates(data, pairCandidates));
Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data); Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data);
List<AssignmentCandidate> rawAssignmentCandidates = createAssignmentCandidates(data,
pairCandidates, dispatchRegionCandidates, unassignedCenterReasons);
List<AssignmentCandidate> residencePreferredCandidates = preferResidenceMatchesByCenter(
rawAssignmentCandidates, unassignedCenterReasons);
List<AssignmentCandidate> assignmentCandidates = trimAssignmentCandidates( List<AssignmentCandidate> assignmentCandidates = trimAssignmentCandidates(
createAssignmentCandidates(data, pairCandidates, dispatchRegionCandidates, residencePreferredCandidates,
unassignedCenterReasons),
data.getCenters(), unassignedCenterReasons); data.getCenters(), unassignedCenterReasons);
return PairingCandidates.builder().pairCandidates(pairCandidates) return PairingCandidates.builder().pairCandidates(pairCandidates)
.dispatchRegionCandidates(dispatchRegionCandidates) .dispatchRegionCandidates(dispatchRegionCandidates)
@@ -59,8 +61,7 @@ public class PairingCandidateService {
for (Member fieldMember : fieldMembers) { for (Member fieldMember : fieldMembers) {
for (Member externalMember : externalMembers) { for (Member externalMember : externalMembers) {
if (!isNewNewPair(fieldMember, externalMember) && hasDateOverlap(fieldMember, if (hasDateOverlap(fieldMember, externalMember)) {
externalMember)) {
candidates.add(PairCandidate.builder().fieldMemberId(fieldMember.getId()) candidates.add(PairCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()) .externalMemberId(externalMember.getId())
.residenceMatchScore(calculateResidenceMatchScore(fieldMember, externalMember)) .residenceMatchScore(calculateResidenceMatchScore(fieldMember, externalMember))
@@ -91,12 +92,12 @@ public class PairingCandidateService {
Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule( Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule(
data.getPreferenceMatchRules(), fieldRank, externalRank); data.getPreferenceMatchRules(), fieldRank, externalRank);
matchRule.ifPresent(preferenceMatchRule -> candidates.add( candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId())
DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId()) .externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion)
.externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion) .preferencePriority(matchRule.map(PreferenceMatchRule::getPriority)
.preferencePriority(preferenceMatchRule.getPriority()) .orElse(fallbackPreferencePriority(data.getPreferenceMatchRules())))
.fieldMemberPreferenceRank(fieldRank).externalMemberPreferenceRank(externalRank) .fieldMemberPreferenceRank(fieldRank).externalMemberPreferenceRank(externalRank)
.build())); .build());
} }
} }
} }
@@ -143,22 +144,24 @@ public class PairingCandidateService {
centerReasons.forEach( centerReasons.forEach(
reason -> addReason(unassignedCenterReasons, center.getId(), reason)); reason -> addReason(unassignedCenterReasons, center.getId(), reason));
} else { } else {
LocalDate firstAssignableDate = findFirstAssignableDate(fieldMember, List<LocalDate> assignableDates = findAssignableDates(fieldMember,
externalMember, municipality, center, commonUnavailableDates(data)); externalMember, municipality, center, commonUnavailableDates(data));
if (firstAssignableDate == null) { if (assignableDates.isEmpty()) {
addReason(unassignedCenterReasons, center.getId(), addReason(unassignedCenterReasons, center.getId(),
"위원/지자체/센터 일정 또는 국공휴일 조건 불일치"); "위원/지자체/센터 일정 또는 국공휴일 조건 불일치");
} else { } else {
candidates.add(AssignmentCandidate.builder().fieldMemberId(fieldMember.getId()) for (LocalDate assignableDate : assignableDates) {
.externalMemberId(externalMember.getId()).centerId(center.getId()) candidates.add(AssignmentCandidate.builder().fieldMemberId(fieldMember.getId())
.municipalityId(center.getMunicipalityId()).date(firstAssignableDate) .externalMemberId(externalMember.getId()).centerId(center.getId())
.dispatchRegion(dispatchCandidate.getDispatchRegion()) .municipalityId(center.getMunicipalityId()).date(assignableDate)
.adjacentRegionClassification(center.getAdjacentRegionClassification()) .dispatchRegion(dispatchCandidate.getDispatchRegion())
.preferencePriority(dispatchCandidate.getPreferencePriority()) .adjacentRegionClassification(center.getAdjacentRegionClassification())
.fieldMemberPreferenceRank(dispatchCandidate.getFieldMemberPreferenceRank()) .preferencePriority(dispatchCandidate.getPreferencePriority())
.externalMemberPreferenceRank(dispatchCandidate.getExternalMemberPreferenceRank()) .fieldMemberPreferenceRank(dispatchCandidate.getFieldMemberPreferenceRank())
.residenceMatchScore( .externalMemberPreferenceRank(dispatchCandidate.getExternalMemberPreferenceRank())
pairCandidate == null ? 0 : pairCandidate.getResidenceMatchScore()).build()); .residenceMatchScore(
pairCandidate == null ? 0 : pairCandidate.getResidenceMatchScore()).build());
}
} }
} }
} }
@@ -168,6 +171,13 @@ public class PairingCandidateService {
return candidates; return candidates;
} }
private List<AssignmentCandidate> preferResidenceMatchesByCenter(
List<AssignmentCandidate> candidates, Map<String, Set<String>> unassignedCenterReasons) {
// 위원 전원 조편성이 0순위 HARD 룰이므로 거주지 유사도는 후보 제거 조건으로 쓰지 않습니다.
// 거주지 3자리/2자리 일치 여부는 solver 점수로만 반영합니다.
return candidates;
}
private List<DispatchRegionCandidate> trimDispatchRegionCandidates( private List<DispatchRegionCandidate> trimDispatchRegionCandidates(
List<DispatchRegionCandidate> candidates) { List<DispatchRegionCandidate> candidates) {
int limit = maxDispatchRegionsPerPair(); int limit = maxDispatchRegionsPerPair();
@@ -189,8 +199,11 @@ public class PairingCandidateService {
List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) { List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) {
List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates); List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates);
List<AssignmentCandidate> trimmedByMember = trimAssignmentsPerMember(trimmedByCenter); List<AssignmentCandidate> trimmedByMember = trimAssignmentsPerMember(trimmedByCenter);
addTrimmedCenterReasons(candidates, trimmedByMember, centers, unassignedCenterReasons); List<AssignmentCandidate> memberPreservedCandidates = preserveMinimumMemberCandidates(
return trimmedByMember; candidates, new ArrayList<>(trimmedByMember), memberUsage(trimmedByMember),
maxAssignmentsPerMember());
addTrimmedCenterReasons(candidates, memberPreservedCandidates, centers, unassignedCenterReasons);
return memberPreservedCandidates;
} }
private List<AssignmentCandidate> trimAssignmentsPerCenter(List<AssignmentCandidate> candidates) { private List<AssignmentCandidate> trimAssignmentsPerCenter(List<AssignmentCandidate> candidates) {
@@ -225,15 +238,68 @@ public class PairingCandidateService {
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0); int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0); int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) { if (fieldCount < limit && externalCount < limit) {
selected.add(candidate); addAssignmentCandidate(selected, memberUsage, candidate);
memberUsage.put(candidate.getFieldMemberId(), fieldCount + 1); }
memberUsage.put(candidate.getExternalMemberId(), externalCount + 1); }
return preserveMinimumMemberCandidates(candidates, selected, memberUsage, limit);
}
private List<AssignmentCandidate> preserveMinimumMemberCandidates(
List<AssignmentCandidate> candidates, List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, int limit) {
Set<String> selectedKeys = selected.stream()
.map(this::assignmentKey)
.collect(Collectors.toSet());
Set<String> missingMemberIds = candidates.stream()
.flatMap(candidate -> java.util.stream.Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.filter(memberId -> memberUsage.getOrDefault(memberId, 0) == 0)
.collect(Collectors.toCollection(LinkedHashSet::new));
for (AssignmentCandidate candidate : candidates.stream()
.sorted(assignmentCandidateComparator())
.toList()) {
if (missingMemberIds.isEmpty()) {
break;
}
if (selectedKeys.contains(assignmentKey(candidate))) {
continue;
}
if (!missingMemberIds.contains(candidate.getFieldMemberId())
&& !missingMemberIds.contains(candidate.getExternalMemberId())) {
continue;
}
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
addAssignmentCandidate(selected, memberUsage, candidate);
selectedKeys.add(assignmentKey(candidate));
missingMemberIds.remove(candidate.getFieldMemberId());
missingMemberIds.remove(candidate.getExternalMemberId());
} }
} }
return selected; return selected;
} }
private void addAssignmentCandidate(List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, AssignmentCandidate candidate) {
selected.add(candidate);
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
}
private Map<String, Integer> memberUsage(List<AssignmentCandidate> candidates) {
Map<String, Integer> memberUsage = new HashMap<>();
candidates.forEach(candidate -> {
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
});
return memberUsage;
}
private void addTrimmedCenterReasons(List<AssignmentCandidate> originalCandidates, private void addTrimmedCenterReasons(List<AssignmentCandidate> originalCandidates,
List<AssignmentCandidate> trimmedCandidates, List<Center> centers, List<AssignmentCandidate> trimmedCandidates, List<Center> centers,
Map<String, Set<String>> unassignedCenterReasons) { Map<String, Set<String>> unassignedCenterReasons) {
@@ -252,11 +318,6 @@ public class PairingCandidateService {
} }
} }
private boolean isNewNewPair(Member fieldMember, Member externalMember) {
return fieldMember.getExperienceType() == ExperienceType.NEW
&& externalMember.getExperienceType() == ExperienceType.NEW;
}
private boolean hasDateOverlap(Member fieldMember, Member externalMember) { private boolean hasDateOverlap(Member fieldMember, Member externalMember) {
LocalDate latestStart = max(fieldMember.getAvailableStartDate(), LocalDate latestStart = max(fieldMember.getAvailableStartDate(),
externalMember.getAvailableStartDate()); externalMember.getAvailableStartDate());
@@ -266,9 +327,21 @@ public class PairingCandidateService {
} }
private int calculateResidenceMatchScore(Member fieldMember, Member externalMember) { private int calculateResidenceMatchScore(Member fieldMember, Member externalMember) {
String fieldPrefix = prefix(fieldMember.getResidenceCode()); if (isSameResidencePrefix(fieldMember, externalMember, residenceMatchPrefixLength())) {
String externalPrefix = prefix(externalMember.getResidenceCode()); return 2;
return !fieldPrefix.isBlank() && fieldPrefix.equals(externalPrefix) ? 1 : 0; }
if (isSameResidencePrefix(fieldMember, externalMember, secondaryResidenceMatchPrefixLength())) {
return 1;
}
return 0;
}
private boolean isSameResidencePrefix(Member fieldMember, Member externalMember, int length) {
String fieldPrefix = prefix(fieldMember.getResidenceCode(), length);
String externalPrefix = prefix(externalMember.getResidenceCode(), length);
return !fieldPrefix.isBlank() && fieldPrefix.equals(externalPrefix);
} }
private boolean isConflictRegion(Member fieldMember, Member externalMember, private boolean isConflictRegion(Member fieldMember, Member externalMember,
@@ -311,6 +384,13 @@ public class PairingCandidateService {
: Optional.empty(); : Optional.empty();
} }
private int fallbackPreferencePriority(List<PreferenceMatchRule> rules) {
return rules.stream()
.mapToInt(PreferenceMatchRule::getPriority)
.max()
.orElse(0) + 1000;
}
private boolean matchesPreferenceRank(int ruleRank, int memberRank) { private boolean matchesPreferenceRank(int ruleRank, int memberRank) {
return ruleRank == ignoredPreferenceRank() || ruleRank == memberRank; return ruleRank == ignoredPreferenceRank() || ruleRank == memberRank;
} }
@@ -331,8 +411,9 @@ public class PairingCandidateService {
return reasons; return reasons;
} }
private LocalDate findFirstAssignableDate(Member fieldMember, Member externalMember, private List<LocalDate> findAssignableDates(Member fieldMember, Member externalMember,
Municipality municipality, Center center, Set<LocalDate> commonUnavailableDates) { Municipality municipality, Center center, Set<LocalDate> commonUnavailableDates) {
List<LocalDate> dates = new ArrayList<>();
LocalDate start = max( LocalDate start = max(
max(fieldMember.getAvailableStartDate(), externalMember.getAvailableStartDate()), max(fieldMember.getAvailableStartDate(), externalMember.getAvailableStartDate()),
max(municipality.getAvailableStartDate(), center.getAvailableStartDate())); max(municipality.getAvailableStartDate(), center.getAvailableStartDate()));
@@ -343,12 +424,15 @@ public class PairingCandidateService {
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) { for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
if (isAvailableOn(date, fieldMember, externalMember, municipality, center, if (isAvailableOn(date, fieldMember, externalMember, municipality, center,
commonUnavailableDates)) { commonUnavailableDates)) {
return date; dates.add(date);
if (dates.size() >= maxDatesPerAssignmentCandidate()) {
break;
}
} }
} }
} }
return null; return dates;
} }
private boolean isAvailableOn(LocalDate date, Member fieldMember, Member externalMember, private boolean isAvailableOn(LocalDate date, Member fieldMember, Member externalMember,
@@ -391,8 +475,17 @@ public class PairingCandidateService {
return fieldMemberId + "|" + externalMemberId; return fieldMemberId + "|" + externalMemberId;
} }
private String assignmentKey(AssignmentCandidate candidate) {
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId() + "|"
+ candidate.getCenterId() + "|" + candidate.getDate();
}
private String prefix(String value) { private String prefix(String value) {
return value.substring(0, Math.min(residenceMatchPrefixLength(), value.length())); return prefix(value, residenceMatchPrefixLength());
}
private String prefix(String value, int length) {
return value.substring(0, Math.min(length, value.length()));
} }
private String anyRegionCode() { private String anyRegionCode() {
@@ -411,6 +504,10 @@ public class PairingCandidateService {
return pairingProperties.getCode().getResidenceMatchPrefixLength(); return pairingProperties.getCode().getResidenceMatchPrefixLength();
} }
private int secondaryResidenceMatchPrefixLength() {
return Math.max(1, residenceMatchPrefixLength() - 1);
}
private int maxDispatchRegionsPerPair() { private int maxDispatchRegionsPerPair() {
return pairingProperties.getCandidate().getMaxDispatchRegionsPerPair(); return pairingProperties.getCandidate().getMaxDispatchRegionsPerPair();
} }
@@ -423,6 +520,10 @@ public class PairingCandidateService {
return pairingProperties.getCandidate().getMaxAssignmentsPerMember(); return pairingProperties.getCandidate().getMaxAssignmentsPerMember();
} }
private int maxDatesPerAssignmentCandidate() {
return pairingProperties.getCandidate().getMaxDatesPerAssignmentCandidate();
}
private Comparator<DispatchRegionCandidate> dispatchRegionCandidateComparator() { private Comparator<DispatchRegionCandidate> dispatchRegionCandidateComparator() {
return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed() return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed()
.thenComparing(DispatchRegionCandidate::getDispatchRegion); .thenComparing(DispatchRegionCandidate::getDispatchRegion);

View File

@@ -0,0 +1,290 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.model.AssignmentCandidate;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.PairCandidate;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingScheduleService {
private final PairingCandidateService pairingCandidateService;
private final PairingSolverService pairingSolverService;
private final PairingProperties pairingProperties;
public PairingResult schedule(PairingData originData) {
List<Center> remainingCenters = new ArrayList<>(originData.getCenters());
List<Member> currentMembers = originData.getMembers();
List<AssignmentCandidate> scheduledAssignments = new ArrayList<>();
List<PairingCandidates> roundCandidates = new ArrayList<>();
Map<String, Set<String>> counterpartsByMember = new HashMap<>();
Map<String, Integer> visitCountsByMember = createInitialVisitCounts(originData.getMembers());
int round = 0;
String stopReason = "센터를 모두 배정했습니다.";
while (!remainingCenters.isEmpty() && round < originData.getCenters().size()) {
round++;
PairingData roundData = copyData(originData, currentMembers, remainingCenters);
PairingCandidates candidates = filterByCounterpartLimit(
pairingCandidateService.generate(roundData), counterpartsByMember);
roundCandidates.add(candidates);
PairingSolverService.SolveSelection selection = pairingSolverService.select(candidates,
counterpartsByMember, visitCountsByMember,
mandatoryUnusedMemberIds(candidates, visitCountsByMember));
if (!selection.hasSolution() || selection.selectedAssignments().isEmpty()) {
stopReason = selection.status();
break;
}
List<AssignmentCandidate> selected = selection.selectedAssignments();
scheduledAssignments.addAll(selected);
addCounterparts(counterpartsByMember, selected);
addVisitCounts(visitCountsByMember, selected);
Set<String> assignedCenterIds = selected.stream()
.map(AssignmentCandidate::getCenterId)
.collect(Collectors.toSet());
remainingCenters = remainingCenters.stream()
.filter(center -> !assignedCenterIds.contains(center.getId()))
.toList();
currentMembers = blockAssignedDates(currentMembers, selected);
}
PairingCandidates mergedCandidates = mergeCandidates(roundCandidates);
PairingResult result = pairingSolverService.buildResult(originData, mergedCandidates,
scheduledAssignments, stopReason(round, remainingCenters, stopReason));
return appendScheduleSummaries(result, round, originData.getCenters().size(),
remainingCenters.size());
}
private PairingData copyData(PairingData originData, List<Member> members, List<Center> centers) {
return PairingData.builder()
.members(members)
.municipalities(originData.getMunicipalities())
.centers(centers)
.memberRegionCodes(originData.getMemberRegionCodes())
.centerAdjacentRegions(originData.getCenterAdjacentRegions())
.preferenceMatchRules(originData.getPreferenceMatchRules())
.commonUnavailableDates(originData.getCommonUnavailableDates())
.build();
}
private List<Member> blockAssignedDates(List<Member> members,
List<AssignmentCandidate> assignments) {
Map<String, Set<LocalDate>> datesByMemberId = new HashMap<>();
for (AssignmentCandidate assignment : assignments) {
datesByMemberId.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>())
.add(assignment.getDate());
datesByMemberId.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>())
.add(assignment.getDate());
}
return members.stream()
.map(member -> copyMemberWithBlockedDates(member,
datesByMemberId.getOrDefault(member.getId(), Set.of())))
.toList();
}
private PairingCandidates filterByCounterpartLimit(PairingCandidates candidates,
Map<String, Set<String>> counterpartsByMember) {
Set<String> allowedPairKeys = candidates.getPairCandidates().stream()
.filter(pair -> isAllowedPair(pair.getFieldMemberId(), pair.getExternalMemberId(),
counterpartsByMember))
.map(pair -> pairKey(pair.getFieldMemberId(), pair.getExternalMemberId()))
.collect(Collectors.toSet());
return PairingCandidates.builder()
.pairCandidates(candidates.getPairCandidates().stream()
.filter(pair -> allowedPairKeys.contains(
pairKey(pair.getFieldMemberId(), pair.getExternalMemberId())))
.toList())
.dispatchRegionCandidates(candidates.getDispatchRegionCandidates().stream()
.filter(candidate -> allowedPairKeys.contains(
pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId())))
.toList())
.assignmentCandidates(candidates.getAssignmentCandidates().stream()
.filter(candidate -> allowedPairKeys.contains(
pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId())))
.toList())
.unassignedCenterReasons(candidates.getUnassignedCenterReasons())
.build();
}
private boolean isAllowedPair(String fieldMemberId, String externalMemberId,
Map<String, Set<String>> counterpartsByMember) {
return isAllowedCounterpart(fieldMemberId, externalMemberId, counterpartsByMember)
&& isAllowedCounterpart(externalMemberId, fieldMemberId, counterpartsByMember);
}
private boolean isAllowedCounterpart(String memberId, String counterpartId,
Map<String, Set<String>> counterpartsByMember) {
Set<String> counterparts = counterpartsByMember.getOrDefault(memberId, Set.of());
return counterparts.contains(counterpartId)
|| counterparts.size() < maxCounterpartsPerMember();
}
private void addCounterparts(Map<String, Set<String>> counterpartsByMember,
List<AssignmentCandidate> assignments) {
for (AssignmentCandidate assignment : assignments) {
counterpartsByMember.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>())
.add(assignment.getExternalMemberId());
counterpartsByMember.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>())
.add(assignment.getFieldMemberId());
}
}
private Map<String, Integer> createInitialVisitCounts(List<Member> members) {
return members.stream()
.collect(Collectors.toMap(Member::getId, member -> 0, (left, right) -> left));
}
private Set<String> mandatoryUnusedMemberIds(PairingCandidates candidates,
Map<String, Integer> visitCountsByMember) {
return visitCountsByMember.entrySet().stream()
.filter(entry -> entry.getValue() == 0)
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
}
private void addVisitCounts(Map<String, Integer> visitCountsByMember,
List<AssignmentCandidate> assignments) {
for (AssignmentCandidate assignment : assignments) {
visitCountsByMember.merge(assignment.getFieldMemberId(), 1, Integer::sum);
visitCountsByMember.merge(assignment.getExternalMemberId(), 1, Integer::sum);
}
}
private List<AssignmentCandidate> filterSelectedByCounterpartLimit(
List<AssignmentCandidate> selectedAssignments,
Map<String, Set<String>> counterpartsByMember) {
Map<String, Set<String>> simulatedCounterparts = copyCounterparts(counterpartsByMember);
List<AssignmentCandidate> allowedAssignments = new ArrayList<>();
for (AssignmentCandidate assignment : selectedAssignments) {
if (isAllowedPair(assignment.getFieldMemberId(), assignment.getExternalMemberId(),
simulatedCounterparts)) {
allowedAssignments.add(assignment);
simulatedCounterparts.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>())
.add(assignment.getExternalMemberId());
simulatedCounterparts.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>())
.add(assignment.getFieldMemberId());
}
}
return allowedAssignments;
}
private Map<String, Set<String>> copyCounterparts(Map<String, Set<String>> source) {
Map<String, Set<String>> copied = new HashMap<>();
source.forEach((memberId, counterparts) -> copied.put(memberId, new HashSet<>(counterparts)));
return copied;
}
private String pairKey(PairCandidate pairCandidate) {
return pairKey(pairCandidate.getFieldMemberId(), pairCandidate.getExternalMemberId());
}
private String pairKey(String fieldMemberId, String externalMemberId) {
return fieldMemberId + "|" + externalMemberId;
}
private int maxCounterpartsPerMember() {
return pairingProperties.getRule().getMaxCounterpartsPerMember();
}
private Member copyMemberWithBlockedDates(Member member, Set<LocalDate> additionalDates) {
if (additionalDates.isEmpty()) {
return member;
}
Set<LocalDate> unavailableDates = new LinkedHashSet<>(member.getUnavailableDates());
unavailableDates.addAll(additionalDates);
return Member.builder()
.id(member.getId())
.gender(member.getGender())
.experienceType(member.getExperienceType())
.role(member.getRole())
.availableStartDate(member.getAvailableStartDate())
.availableEndDate(member.getAvailableEndDate())
.unavailableDates(unavailableDates)
.activityRegion(member.getActivityRegion())
.historyCenterIds(member.getHistoryCenterIds())
.residenceCode(member.getResidenceCode())
.preferenceRegions(member.getPreferenceRegions())
.build();
}
private PairingCandidates mergeCandidates(List<PairingCandidates> roundCandidates) {
Map<String, Set<String>> reasons = new LinkedHashMap<>();
roundCandidates.stream()
.map(PairingCandidates::getUnassignedCenterReasons)
.forEach(reasonMap -> reasonMap.forEach((centerId, centerReasons) ->
reasons.computeIfAbsent(centerId, key -> new LinkedHashSet<>()).addAll(centerReasons)));
return PairingCandidates.builder()
.pairCandidates(roundCandidates.stream()
.flatMap(candidates -> candidates.getPairCandidates().stream())
.toList())
.dispatchRegionCandidates(roundCandidates.stream()
.flatMap(candidates -> candidates.getDispatchRegionCandidates().stream())
.toList())
.assignmentCandidates(roundCandidates.stream()
.flatMap(candidates -> candidates.getAssignmentCandidates().stream())
.toList())
.unassignedCenterReasons(reasons)
.build();
}
private String stopReason(int round, List<Center> remainingCenters, String stopReason) {
if (remainingCenters.isEmpty()) {
return "SCHEDULE_COMPLETED";
}
return "SCHEDULE_STOPPED round=" + round + ", remainingCenters=" + remainingCenters.size()
+ ", reason=" + stopReason;
}
private PairingResult appendScheduleSummaries(PairingResult result, int round,
int originalCenterCount, int remainingCenterCount) {
List<PairingSummaryExcelDto> summaries = new ArrayList<>(result.getSummaries());
summaries.add(new PairingSummaryExcelDto("스케줄링 라운드 수", String.valueOf(round)));
summaries.add(new PairingSummaryExcelDto("스케줄링 시작 센터 수", String.valueOf(originalCenterCount)));
summaries.add(new PairingSummaryExcelDto("스케줄링 잔여 센터 수", String.valueOf(remainingCenterCount)));
List<CandidateSummaryExcelDto> candidateSummaries = new ArrayList<>(
result.getCandidateSummaries());
candidateSummaries.add(new CandidateSummaryExcelDto("스케줄링 라운드 수",
String.valueOf(round), "배정 후 위원 불가일과 잔여 센터를 갱신한 반복 횟수"));
return PairingResult.builder()
.assignments(result.getAssignments())
.unassignedCenters(result.getUnassignedCenters())
.unusedMembers(result.getUnusedMembers())
.summaries(summaries)
.abPairs(result.getAbPairs())
.candidateSummaries(candidateSummaries)
.validationErrors(result.getValidationErrors())
.ruleViolations(result.getRuleViolations())
.build();
}
}

View File

@@ -1,7 +1,6 @@
package com.kri.p6.ncrc.pairing.service; package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData; import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData; import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult; import com.kri.p6.ncrc.pairing.model.PairingResult;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@@ -16,16 +15,14 @@ public class PairingService {
private final PairingNormalizeService pairingNormalizeService; private final PairingNormalizeService pairingNormalizeService;
private final PairingHolidayService pairingHolidayService; private final PairingHolidayService pairingHolidayService;
private final PairingValidationService pairingValidationService; private final PairingValidationService pairingValidationService;
private final PairingCandidateService pairingCandidateService; private final PairingScheduleService pairingScheduleService;
private final PairingSolverService pairingSolverService;
public byte[] pairingMemberByCenter(MultipartFile file) { public byte[] pairingMemberByCenter(MultipartFile file) {
PairingWorkbookData workbookData = pairingExcelService.read(file); PairingWorkbookData workbookData = pairingExcelService.read(file);
PairingData pairingData = pairingNormalizeService.normalize(workbookData); PairingData pairingData = pairingNormalizeService.normalize(workbookData);
pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData); pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData);
pairingValidationService.validate(pairingData); pairingValidationService.validate(pairingData);
PairingCandidates candidates = pairingCandidateService.generate(pairingData); PairingResult result = pairingScheduleService.schedule(pairingData);
PairingResult result = pairingSolverService.solve(pairingData, candidates);
return pairingExcelService.write(result); return pairingExcelService.write(result);
} }
} }

View File

@@ -48,95 +48,167 @@ public class PairingSolverService {
private final PairingProperties pairingProperties; private final PairingProperties pairingProperties;
public PairingResult solve(PairingData data, PairingCandidates candidates) { public PairingResult solve(PairingData data, PairingCandidates candidates) {
if (candidates.getAssignmentCandidates().isEmpty()) { SolveSelection selection = select(candidates);
return emptyResult(data, candidates, "배정 가능한 후보가 없습니다."); if (!selection.hasSolution()) {
} else { return emptyResult(data, candidates, selection.status());
CpModel model = new CpModel();
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates);
Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model,
assignmentCandidates);
linkHelperVars(model, assignmentCandidates, assignmentVars, pairUsedVars, pairDayVars,
pairDayAdjacentVars);
addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars);
addPairDailyCapacity(model, assignmentCandidates, assignmentVars);
addMemberDailyOnePair(model, assignmentCandidates, pairDayVars);
addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars);
addBuddyLimit(model, assignmentCandidates, pairUsedVars);
model.maximize(createObjective(assignmentCandidates, assignmentVars));
CpSolver solver = new CpSolver();
solver.getParameters()
.setMaxTimeInSeconds(pairingProperties.getSolver().getMaxTimeSeconds());
solver.getParameters()
.setNumSearchWorkers(pairingProperties.getSolver().getNumSearchWorkers());
CpSolverStatus status = solver.solve(model);
if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE) {
return emptyResult(data, candidates,
"solver가 feasible 해를 찾지 못했습니다: " + String.valueOf(status));
} else {
List<AssignmentCandidate> selectedAssignments = collectSelectedAssignments(
assignmentCandidates, assignmentVars, solver);
return toResult(data, candidates, selectedAssignments, status);
}
} }
return toResult(data, candidates, selection.selectedAssignments(), selection.status());
}
public SolveSelection select(PairingCandidates candidates) {
return select(candidates, Map.of());
}
public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember) {
return select(candidates, existingCounterpartsByMember, Map.of(), Set.of());
}
public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember, Map<String, Integer> visitCountsByMember,
Set<String> mandatoryMemberIds) {
return select(candidates, existingCounterpartsByMember, visitCountsByMember, mandatoryMemberIds,
true);
}
private SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember, Map<String, Integer> visitCountsByMember,
Set<String> mandatoryMemberIds, boolean enforceCounterpartLimit) {
if (candidates.getAssignmentCandidates().isEmpty()) {
return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다.");
}
CpModel model = new CpModel();
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates);
Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model, assignmentCandidates);
Map<String, BoolVar> memberUsedVars = createMemberUsedVars(model, assignmentCandidates);
Set<String> missingMandatoryMemberIds = mandatoryMemberIds.stream()
.filter(memberId -> !memberUsedVars.containsKey(memberId))
.collect(Collectors.toCollection(LinkedHashSet::new));
if (!missingMandatoryMemberIds.isEmpty()) {
return new SolveSelection(false, List.of(),
"필수 조편성 위원의 배정 후보가 없습니다: " + String.join(", ", missingMandatoryMemberIds));
}
linkHelperVars(model, assignmentCandidates, assignmentVars, pairUsedVars, pairDayVars, pairDayAdjacentVars);
linkMemberUsedVars(model, assignmentCandidates, assignmentVars, memberUsedVars);
addMandatoryMemberUsed(model, memberUsedVars, mandatoryMemberIds);
addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars);
addPairDailyCapacity(model, assignmentCandidates, assignmentVars);
addMemberDailyOnePair(model, assignmentCandidates, pairDayVars);
addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars);
if (enforceCounterpartLimit) {
addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars,
existingCounterpartsByMember);
}
model.maximize(createObjective(assignmentCandidates, assignmentVars, memberUsedVars,
visitCountsByMember));
CpSolver solver = new CpSolver();
solver.getParameters().setMaxTimeInSeconds(pairingProperties.getSolver().getMaxTimeSeconds());
solver.getParameters().setNumSearchWorkers(pairingProperties.getSolver().getNumSearchWorkers());
CpSolverStatus status = solver.solve(model);
if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE) {
if (enforceCounterpartLimit && !mandatoryMemberIds.isEmpty()) {
SolveSelection counterpartRelaxedSelection = select(candidates,
existingCounterpartsByMember, visitCountsByMember, mandatoryMemberIds, false);
if (counterpartRelaxedSelection.hasSolution()) {
return new SolveSelection(true, counterpartRelaxedSelection.selectedAssignments(),
counterpartRelaxedSelection.status() + ", counterpartLimitRelaxed=true");
}
}
return new SolveSelection(false, List.of(), "solver가 feasible 해를 찾지 못했습니다: " + status);
}
return new SolveSelection(true, collectSelectedAssignments(assignmentCandidates, assignmentVars, solver), status.name());
}
public PairingResult buildResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status) {
return toResult(data, candidates, selectedAssignments, status);
} }
private BoolVar[] createAssignmentVars(CpModel model, List<AssignmentCandidate> candidates) { private BoolVar[] createAssignmentVars(CpModel model, List<AssignmentCandidate> candidates) {
BoolVar[] vars = new BoolVar[candidates.size()]; BoolVar[] vars = new BoolVar[candidates.size()];
for (int i = 0; i < candidates.size(); i++) {
for (int i = 0; i < candidates.size(); ++i) { vars[i] = model.newBoolVar("assign_" + i + "_" + candidates.get(i).getCenterId());
AssignmentCandidate candidate = candidates.get(i);
vars[i] = model.newBoolVar("assign_" + i + "_" + candidate.getCenterId());
} }
return vars; return vars;
} }
private Map<String, BoolVar> createPairUsedVars(CpModel model, private Map<String, BoolVar> createPairUsedVars(CpModel model, List<AssignmentCandidate> candidates) {
List<AssignmentCandidate> candidates) { return candidates.stream().map(this::pairKey).distinct()
return candidates.stream().map(this::pairKey).distinct().collect( .collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_used_" + key)));
Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_used_" + key)));
} }
private Map<String, BoolVar> createPairDayVars(CpModel model, private Map<String, BoolVar> createPairDayVars(CpModel model, List<AssignmentCandidate> candidates) {
List<AssignmentCandidate> candidates) { return candidates.stream().map(this::pairDayKey).distinct()
return candidates.stream().map(this::pairDayKey).distinct().collect( .collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_" + key)));
Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_" + key)));
} }
private Map<String, BoolVar> createPairDayAdjacentVars(CpModel model, private Map<String, BoolVar> createPairDayAdjacentVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayAdjacentKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_adjacent_" + key)));
}
private Map<String, BoolVar> createMemberUsedVars(CpModel model,
List<AssignmentCandidate> candidates) { List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayAdjacentKey).distinct().collect( return candidates.stream()
Collectors.toMap(Function.identity(), .flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
key -> model.newBoolVar("pair_day_adjacent_" + key))); candidate.getExternalMemberId()))
.distinct()
.collect(Collectors.toMap(Function.identity(),
memberId -> model.newBoolVar("member_used_" + memberId)));
} }
private void linkHelperVars(CpModel model, List<AssignmentCandidate> candidates, private void linkHelperVars(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> pairUsedVars, Map<String, BoolVar> pairDayVars, BoolVar[] assignmentVars, Map<String, BoolVar> pairUsedVars, Map<String, BoolVar> pairDayVars,
Map<String, BoolVar> pairDayAdjacentVars) { Map<String, BoolVar> pairDayAdjacentVars) {
for (int i = 0; i < candidates.size(); ++i) { for (int i = 0; i < candidates.size(); i++) {
AssignmentCandidate candidate = candidates.get(i); AssignmentCandidate candidate = candidates.get(i);
model.addLessOrEqual(assignmentVars[i], pairUsedVars.get(pairKey(candidate))); model.addLessOrEqual(assignmentVars[i], pairUsedVars.get(pairKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayVars.get(pairDayKey(candidate))); model.addLessOrEqual(assignmentVars[i], pairDayVars.get(pairDayKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayAdjacentVars.get(pairDayAdjacentKey(candidate))); model.addLessOrEqual(assignmentVars[i], pairDayAdjacentVars.get(pairDayAdjacentKey(candidate)));
} }
}
private void linkMemberUsedVars(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars) {
Map<String, List<Integer>> indexesByMember = new HashMap<>();
for (int i = 0; i < candidates.size(); i++) {
AssignmentCandidate candidate = candidates.get(i);
indexesByMember.computeIfAbsent(candidate.getFieldMemberId(), key -> new ArrayList<>())
.add(i);
indexesByMember.computeIfAbsent(candidate.getExternalMemberId(), key -> new ArrayList<>())
.add(i);
model.addLessOrEqual(assignmentVars[i], memberUsedVars.get(candidate.getFieldMemberId()));
model.addLessOrEqual(assignmentVars[i], memberUsedVars.get(candidate.getExternalMemberId()));
}
indexesByMember.forEach((memberId, indexes) -> model.addLessOrEqual(
memberUsedVars.get(memberId), LinearExpr.sum(toLinearArgumentArray(indexes,
assignmentVars))));
}
private void addMandatoryMemberUsed(CpModel model, Map<String, BoolVar> memberUsedVars,
Set<String> mandatoryMemberIds) {
mandatoryMemberIds.stream()
.map(memberUsedVars::get)
.filter(Objects::nonNull)
.forEach(memberUsedVar -> model.addEquality(memberUsedVar, 1));
} }
private void addCenterAssignedAtMostOnce(CpModel model, List<AssignmentCandidate> candidates, private void addCenterAssignedAtMostOnce(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) { BoolVar[] assignmentVars) {
Map<String, List<Integer>> indexesByCenter = groupIndexes(candidates, groupIndexes(candidates, AssignmentCandidate::getCenterId).values()
AssignmentCandidate::getCenterId);
indexesByCenter.values()
.forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars))); .forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars)));
} }
private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates, private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) { BoolVar[] assignmentVars) {
Map<String, List<Integer>> indexesByPairDay = groupIndexes(candidates, this::pairDayKey); groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual(
indexesByPairDay.values().forEach(indexes -> model.addLessOrEqual(
LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)), LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)),
pairingProperties.getRule().getMaxCentersPerPairPerDay())); pairingProperties.getRule().getMaxCentersPerPairPerDay()));
} }
@@ -144,110 +216,118 @@ public class PairingSolverService {
private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates, private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairDayVars) { Map<String, BoolVar> pairDayVars) {
Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream() Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> { .collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(),
String var10000 = candidate.getFieldMemberId(); Collectors.mapping(this::pairDayKey, Collectors.toSet())));
return var10000 + "|" + candidate.getDate();
}, Collectors.mapping(this::pairDayKey, Collectors.toSet())));
Map<String, Set<String>> externalPairDayKeysByMemberDay = candidates.stream() Map<String, Set<String>> externalPairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> { .collect(Collectors.groupingBy(candidate -> candidate.getExternalMemberId() + "|" + candidate.getDate(),
String var10000 = candidate.getExternalMemberId(); Collectors.mapping(this::pairDayKey, Collectors.toSet())));
return var10000 + "|" + candidate.getDate(); externalPairDayKeysByMemberDay.forEach((key, value) -> pairDayKeysByMemberDay.merge(key, value, (left, right) -> {
}, Collectors.mapping(this::pairDayKey, Collectors.toSet()))); left.addAll(right);
return left;
externalPairDayKeysByMemberDay.forEach( }));
(key, value) -> pairDayKeysByMemberDay.merge(key, value, (left, right) -> { pairDayKeysByMemberDay.values().forEach(pairDayKeys ->
left.addAll(right); model.addAtMostOne(pairDayKeys.stream().map(pairDayVars::get).toArray(BoolVar[]::new)));
return left;
}));
pairDayKeysByMemberDay.values().forEach(pairDayKeys -> {
Stream<String> var10001 = pairDayKeys.stream();
Objects.requireNonNull(pairDayVars);
model.addAtMostOne(var10001.map(pairDayVars::get).toArray(BoolVar[]::new));
});
} }
private void addPairDailyOneAdjacentClassification(CpModel model, private void addPairDailyOneAdjacentClassification(CpModel model,
List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) { List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) {
Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream().collect( Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream()
Collectors.groupingBy(this::pairDayKey, .collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet()))); Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet())));
adjacentKeysByPairDay.values().forEach(adjacentKeys -> { adjacentKeysByPairDay.values().forEach(adjacentKeys ->
Stream<String> var10001 = adjacentKeys.stream(); model.addAtMostOne(adjacentKeys.stream().map(pairDayAdjacentVars::get).toArray(BoolVar[]::new)));
Objects.requireNonNull(pairDayAdjacentVars);
model.addAtMostOne(var10001.map(pairDayAdjacentVars::get).toArray(BoolVar[]::new));
});
} }
private void addBuddyLimit(CpModel model, List<AssignmentCandidate> candidates, private void addCumulativeBuddyLimit(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairUsedVars) { Map<String, BoolVar> pairUsedVars, Map<String, Set<String>> existingCounterpartsByMember) {
Map<String, Set<String>> pairKeysByMember = candidates.stream().collect( Map<String, Set<String>> pairKeysByMember = candidates.stream()
Collectors.groupingBy(AssignmentCandidate::getFieldMemberId, .collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet()))); Collectors.mapping(this::pairKey, Collectors.toSet())));
Map<String, Set<String>> externalPairKeysByMember = candidates.stream().collect( Map<String, Set<String>> externalPairKeysByMember = candidates.stream()
Collectors.groupingBy(AssignmentCandidate::getExternalMemberId, .collect(Collectors.groupingBy(AssignmentCandidate::getExternalMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet()))); Collectors.mapping(this::pairKey, Collectors.toSet())));
externalPairKeysByMember.forEach( externalPairKeysByMember.forEach((key, value) -> pairKeysByMember.merge(key, value, (left, right) -> {
(key, value) -> pairKeysByMember.merge(key, value, (left, right) -> { left.addAll(right);
left.addAll(right); return left;
return left; }));
})); pairKeysByMember.forEach((memberId, pairKeys) -> {
pairKeysByMember.values().forEach(pairKeys -> { Set<String> existingCounterparts = existingCounterpartsByMember.getOrDefault(memberId,
Stream<String> var10001 = pairKeys.stream(); Set.of());
Objects.requireNonNull(pairUsedVars); List<BoolVar> newCounterpartVars = pairKeys.stream()
model.addLessOrEqual(LinearExpr.sum((LinearArgument[]) var10001.map(pairUsedVars::get) .filter(pairKey -> !existingCounterparts.contains(counterpartId(pairKey, memberId)))
.toArray(LinearArgument[]::new)), .map(pairUsedVars::get)
pairingProperties.getRule().getMaxCounterpartsPerMember()); .toList();
if (newCounterpartVars.isEmpty()) {
return;
}
int remainingNewCounterpartSlots = Math.max(0,
pairingProperties.getRule().getMaxCounterpartsPerMember() - existingCounterparts.size());
model.addLessOrEqual(
LinearExpr.sum(newCounterpartVars.toArray(LinearArgument[]::new)),
remainingNewCounterpartSlots);
}); });
} }
private LinearExpr createObjective(List<AssignmentCandidate> candidates, private LinearExpr createObjective(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) { BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars,
LinearArgument[] vars = new LinearArgument[assignmentVars.length]; Map<String, Integer> visitCountsByMember) {
long[] weights = new long[assignmentVars.length]; List<LinearArgument> vars = new ArrayList<>();
List<Long> weights = new ArrayList<>();
for (int i = 0; i < assignmentVars.length; ++i) { for (int i = 0; i < assignmentVars.length; i++) {
AssignmentCandidate candidate = candidates.get(i); AssignmentCandidate candidate = candidates.get(i);
vars[i] = assignmentVars[i]; vars.add(assignmentVars[i]);
weights[i] = pairingProperties.getObjective().getAssignmentWeight() + Math.max(0L, weights.add(pairingProperties.getObjective().getAssignmentWeight()
pairingProperties.getObjective().getPreferenceBaseWeight() + Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
- candidate.getPreferencePriority() * pairingProperties.getObjective() - candidate.getPreferencePriority() * pairingProperties.getObjective().getPreferenceRankPenalty())
.getPreferenceRankPenalty()) + candidate.getResidenceMatchScore() * pairingProperties.getObjective().getResidenceMatchWeight()
+ candidate.getResidenceMatchScore() * pairingProperties.getObjective() - memberBalancePenalty(candidate, visitCountsByMember));
.getResidenceMatchWeight();
} }
return LinearExpr.weightedSum(vars, weights); memberUsedVars.forEach((memberId, memberUsedVar) -> {
if (visitCountsByMember.getOrDefault(memberId, 0) == 0) {
vars.add(memberUsedVar);
weights.add(pairingProperties.getObjective().getUsedMemberWeight());
}
});
return LinearExpr.weightedSum(vars.toArray(LinearArgument[]::new),
weights.stream().mapToLong(Long::longValue).toArray());
}
private long memberBalancePenalty(AssignmentCandidate candidate,
Map<String, Integer> visitCountsByMember) {
return (long) (visitCountsByMember.getOrDefault(candidate.getFieldMemberId(), 0)
+ visitCountsByMember.getOrDefault(candidate.getExternalMemberId(), 0))
* pairingProperties.getObjective().getMemberBalanceWeight();
} }
private List<AssignmentCandidate> collectSelectedAssignments(List<AssignmentCandidate> candidates, private List<AssignmentCandidate> collectSelectedAssignments(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, CpSolver solver) { BoolVar[] assignmentVars, CpSolver solver) {
List<AssignmentCandidate> selected = new ArrayList<>(); List<AssignmentCandidate> selected = new ArrayList<>();
for (int i = 0; i < candidates.size(); i++) {
for (int i = 0; i < candidates.size(); ++i) { if (solver.booleanValue(assignmentVars[i])) {
if (Boolean.TRUE.equals(solver.booleanValue(assignmentVars[i]))) {
selected.add(candidates.get(i)); selected.add(candidates.get(i));
} }
} }
selected.sort(Comparator.comparing(AssignmentCandidate::getDate) selected.sort(Comparator.comparing(AssignmentCandidate::getDate)
.thenComparing(AssignmentCandidate::getFieldMemberId) .thenComparing(AssignmentCandidate::getFieldMemberId)
.thenComparing(AssignmentCandidate::getCenterId)); .thenComparing(AssignmentCandidate::getCenterId));
return selected; return selected;
} }
private PairingResult toResult(PairingData data, PairingCandidates candidates, private PairingResult toResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, CpSolverStatus status) { List<AssignmentCandidate> selectedAssignments, String status) {
Set<String> assignedCenterIds = selectedAssignments.stream().map(AssignmentCandidate::getCenterId).collect(Collectors.toSet()); Set<String> assignedCenterIds = selectedAssignments.stream().map(AssignmentCandidate::getCenterId).collect(Collectors.toSet());
Set<String> usedMemberIds = selectedAssignments.stream().flatMap( Set<String> usedMemberIds = selectedAssignments.stream()
candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId())).collect(Collectors.toSet() .flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId()))
); .collect(Collectors.toSet());
Map<String, Member> memberMap = data.getMembers().stream() Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left)); .collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream() Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left)); .collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
ABPairBuildResult abPairBuildResult = createABPairMatches(selectedAssignments); ABPairBuildResult abPairBuildResult = createABPairMatches(selectedAssignments);
Map<String, ABPairMatch> abPairMatches = abPairBuildResult.matches(); Map<String, ABPairMatch> abPairMatches = abPairBuildResult.matches();
List<AssignmentResultExcelDto> assignments = selectedAssignments.stream() List<AssignmentResultExcelDto> assignments = selectedAssignments.stream()
.map(candidate -> toAssignmentResult(candidate, memberMap, centerMap, abPairMatches)) .map(candidate -> toAssignmentResult(candidate, memberMap, centerMap, abPairMatches))
.toList(); .toList();
@@ -256,30 +336,38 @@ public class PairingSolverService {
.map(center -> toUnassignedCenter(center, candidates.getUnassignedCenterReasons())) .map(center -> toUnassignedCenter(center, candidates.getUnassignedCenterReasons()))
.toList(); .toList();
List<UnusedMemberExcelDto> unusedMembers = data.getMembers().stream() List<UnusedMemberExcelDto> unusedMembers = data.getMembers().stream()
.filter(member -> !usedMemberIds.contains(member.getId())).map( .filter(member -> !usedMemberIds.contains(member.getId()))
member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(), .map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(),
"선택된 최적해에 포함되지 않았습니다. 후보 부족 또는 제약 충돌 가능")).toList(); "최종 배정에 포함되지 않았습니다. 후보 부족 또는 제약 충돌 가능"))
return PairingResult.builder().assignments(assignments).unassignedCenters(unassignedCenters) .toList();
.unusedMembers(unusedMembers).summaries(
createSummaries(data, candidates, assignments.size(), unassignedCenters.size(), return PairingResult.builder()
unusedMembers.size(), countABGroups(abPairMatches), status.name())) .assignments(assignments)
.abPairs(abPairBuildResult.rows()).candidateSummaries( .unassignedCenters(unassignedCenters)
createCandidateSummaries(data, candidates, assignments.size(), .unusedMembers(unusedMembers)
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches))) .summaries(createSummaries(data, candidates, assignments.size(), unassignedCenters.size(),
unusedMembers.size(), countABGroups(abPairMatches), status))
.abPairs(abPairBuildResult.rows())
.candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(),
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches)))
.validationErrors(List.of()) .validationErrors(List.of())
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches)).build(); .ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches))
.build();
} }
private PairingResult emptyResult(PairingData data, PairingCandidates candidates, String reason) { private PairingResult emptyResult(PairingData data, PairingCandidates candidates, String reason) {
return PairingResult.builder().assignments(List.of()).unassignedCenters( return PairingResult.builder()
data.getCenters().stream().map( .assignments(List.of())
center -> new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), .unassignedCenters(data.getCenters().stream()
reason)).toList()).unusedMembers(data.getMembers().stream() .map(center -> new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), reason))
.toList())
.unusedMembers(data.getMembers().stream()
.map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(), reason)) .map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(), reason))
.toList()).summaries(createSummaries(data, candidates, 0, data.getCenters().size(), .toList())
data.getMembers().size(), 0, reason)).abPairs(List.of()).candidateSummaries( .summaries(createSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0, reason))
createCandidateSummaries(data, candidates, 0, data.getCenters().size(), .abPairs(List.of())
data.getMembers().size(), 0)).validationErrors(List.of()) .candidateSummaries(createCandidateSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0))
.validationErrors(List.of())
.ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason))) .ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason)))
.build(); .build();
} }
@@ -294,12 +382,10 @@ public class PairingSolverService {
return new AssignmentResultExcelDto(candidate.getDate().toString(), return new AssignmentResultExcelDto(candidate.getDate().toString(),
candidate.getFieldMemberId(), formatGender(fieldMember.getGender()), candidate.getFieldMemberId(), formatGender(fieldMember.getGender()),
formatExperience(fieldMember.getExperienceType()), fieldMember.getResidenceCode(), formatExperience(fieldMember.getExperienceType()), fieldMember.getResidenceCode(),
fieldMember.getActivityRegion(), fieldMember.getActivityRegion(), formatPreferenceRank(candidate.getFieldMemberPreferenceRank()),
formatPreferenceRank(candidate.getFieldMemberPreferenceRank()),
candidate.getExternalMemberId(), formatGender(externalMember.getGender()), candidate.getExternalMemberId(), formatGender(externalMember.getGender()),
formatExperience(externalMember.getExperienceType()), formatExperience(externalMember.getExperienceType()), externalMember.getResidenceCode(),
externalMember.getResidenceCode(), externalMember.getActivityRegion(), externalMember.getActivityRegion(), formatPreferenceRank(candidate.getExternalMemberPreferenceRank()),
formatPreferenceRank(candidate.getExternalMemberPreferenceRank()),
candidate.getCenterId(), candidate.getMunicipalityId(), center.isWomenOnly() ? "1" : "0", candidate.getCenterId(), candidate.getMunicipalityId(), center.isWomenOnly() ? "1" : "0",
candidate.getDispatchRegion(), candidate.getAdjacentRegionClassification(), candidate.getDispatchRegion(), candidate.getAdjacentRegionClassification(),
String.valueOf(candidate.getPreferencePriority()), String.valueOf(candidate.getPreferencePriority()),
@@ -308,13 +394,11 @@ public class PairingSolverService {
abPairMatch == null ? "" : abPairMatch.getCounterpartExternalMemberId()); abPairMatch == null ? "" : abPairMatch.getCounterpartExternalMemberId());
} }
private UnassignedCenterExcelDto toUnassignedCenter(Center center, private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map<String, Set<String>> reasonMap) {
Map<String, Set<String>> reasonMap) { Set<String> reasons = new LinkedHashSet<>((Collection<String>) (reasonMap == null ? Set.of()
Set<String> reasons = new LinkedHashSet((Collection) (reasonMap == null ? Set.of() : reasonMap.getOrDefault(center.getId(), Set.of())));
: (Collection) reasonMap.getOrDefault(center.getId(), Set.of()))); reasons.add("solver 최적화에서 선택되지 않음");
reasons.add("solver 최적해에서 선택되지 않음"); return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons));
return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(),
String.join(", ", reasons));
} }
private String formatGender(Gender gender) { private String formatGender(Gender gender) {
@@ -328,23 +412,20 @@ public class PairingSolverService {
private String formatPreferenceRank(int rank) { private String formatPreferenceRank(int rank) {
if (rank == 0) { if (rank == 0) {
return "00"; return "00";
} else {
return rank == 99 ? "99" : String.valueOf(rank);
} }
return rank == 99 ? "99" : String.valueOf(rank);
} }
private List<PairingSummaryExcelDto> createSummaries(PairingData data, private List<PairingSummaryExcelDto> createSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount, PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount, String status) { int unusedMemberCount, int abGroupCount, String status) {
return List.of(new PairingSummaryExcelDto("위원 수", String.valueOf(data.getMembers().size())), return List.of(
new PairingSummaryExcelDto("위원 수", String.valueOf(data.getMembers().size())),
new PairingSummaryExcelDto("지자체 수", String.valueOf(data.getMunicipalities().size())), new PairingSummaryExcelDto("지자체 수", String.valueOf(data.getMunicipalities().size())),
new PairingSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size())), new PairingSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size())),
new PairingSummaryExcelDto("페어 후보 수", new PairingSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size())),
String.valueOf(candidates.getPairCandidates().size())), new PairingSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size())),
new PairingSummaryExcelDto("파견 권역 후보 수", new PairingSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size())),
String.valueOf(candidates.getDispatchRegionCandidates().size())),
new PairingSummaryExcelDto("배정 후보 수",
String.valueOf(candidates.getAssignmentCandidates().size())),
new PairingSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount)), new PairingSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount)),
new PairingSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount)), new PairingSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount)),
new PairingSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount)), new PairingSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount)),
@@ -356,41 +437,45 @@ public class PairingSolverService {
Map<String, List<AssignmentCandidate>> assignmentsByPair = selectedAssignments.stream() Map<String, List<AssignmentCandidate>> assignmentsByPair = selectedAssignments.stream()
.collect(Collectors.groupingBy(this::pairKey)); .collect(Collectors.groupingBy(this::pairKey));
List<UsedPair> usedPairs = assignmentsByPair.entrySet().stream() List<UsedPair> usedPairs = assignmentsByPair.entrySet().stream()
.map(entry -> PairingSolverService.UsedPair.of(entry.getKey(), entry.getValue())) .map(entry -> UsedPair.of(entry.getKey(), entry.getValue()))
.sorted(Comparator.comparing(UsedPair::pairKey)).toList(); .sorted(Comparator.comparing(UsedPair::pairKey))
.toList();
Map<String, ABPairMatch> matches = new HashMap<>(); Map<String, ABPairMatch> matches = new HashMap<>();
List<ABPairExcelDto> rows = new ArrayList<>(); List<ABPairExcelDto> rows = new ArrayList<>();
Set<String> alreadyMatched = new HashSet<>(); Set<String> alreadyMatched = new HashSet<>();
int groupSequence = 1; int groupSequence = 1;
for (UsedPair pair : usedPairs) { for (UsedPair pair : usedPairs) {
if (!alreadyMatched.contains(pair.pairKey())) { if (alreadyMatched.contains(pair.pairKey())) {
UsedPair counterpart = usedPairs.stream() continue;
.filter(candidate -> !alreadyMatched.contains(candidate.pairKey()))
.filter(candidate -> !candidate.pairKey().equals(pair.pairKey()))
.filter(pair::canBeABWith)
.findFirst()
.orElse(null);
if (counterpart != null) {
Object[] var10001 = new Object[]{groupSequence++};
String groupId = "AB-" + String.format("%03d", var10001);
matches.put(pair.pairKey(), toABPairMatch(groupId, pair, counterpart));
matches.put(counterpart.pairKey(), toABPairMatch(groupId, counterpart, pair));
rows.add(toABPairRow(groupId, pair, counterpart));
alreadyMatched.add(pair.pairKey());
alreadyMatched.add(counterpart.pairKey());
}
} }
UsedPair counterpart = usedPairs.stream()
.filter(candidate -> !alreadyMatched.contains(candidate.pairKey()))
.filter(candidate -> !candidate.pairKey().equals(pair.pairKey()))
.filter(pair::canBeABWith)
.findFirst()
.orElse(null);
if (counterpart == null) {
continue;
}
String groupId = "AB-" + String.format("%03d", groupSequence++);
matches.put(pair.pairKey(), toABPairMatch(groupId, pair, counterpart));
matches.put(counterpart.pairKey(), toABPairMatch(groupId, counterpart, pair));
rows.add(toABPairRow(groupId, pair, counterpart));
alreadyMatched.add(pair.pairKey());
alreadyMatched.add(counterpart.pairKey());
} }
return new ABPairBuildResult(matches, rows); return new ABPairBuildResult(matches, rows);
} }
private ABPairMatch toABPairMatch(String groupId, UsedPair pair, UsedPair counterpart) { private ABPairMatch toABPairMatch(String groupId, UsedPair pair, UsedPair counterpart) {
return ABPairMatch.builder().groupId(groupId).fieldMemberId(pair.fieldMemberId()) return ABPairMatch.builder()
.groupId(groupId)
.fieldMemberId(pair.fieldMemberId())
.externalMemberId(pair.externalMemberId()) .externalMemberId(pair.externalMemberId())
.counterpartFieldMemberId(counterpart.fieldMemberId()) .counterpartFieldMemberId(counterpart.fieldMemberId())
.counterpartExternalMemberId(counterpart.externalMemberId()).build(); .counterpartExternalMemberId(counterpart.externalMemberId())
.build();
} }
private int countABGroups(Map<String, ABPairMatch> matches) { private int countABGroups(Map<String, ABPairMatch> matches) {
@@ -405,51 +490,34 @@ public class PairingSolverService {
.findFirst() .findFirst()
.orElse(""); .orElse("");
boolean dateOverlapped = pair.dates().stream().anyMatch(counterpart.dates()::contains); boolean dateOverlapped = pair.dates().stream().anyMatch(counterpart.dates()::contains);
return new ABPairExcelDto( return new ABPairExcelDto(groupId, pair.fieldMemberId(), pair.externalMemberId(),
groupId, counterpart.fieldMemberId(), counterpart.externalMemberId(), sharedDispatchRegion,
pair.fieldMemberId(), formatDates(pair.dates()), formatDates(counterpart.dates()), dateOverlapped ? "Y" : "N");
pair.externalMemberId(),
counterpart.fieldMemberId(),
counterpart.externalMemberId(),
sharedDispatchRegion,
formatDates(pair.dates()),
formatDates(counterpart.dates()),
dateOverlapped ? "Y" : "N"
);
} }
private List<CandidateSummaryExcelDto> createCandidateSummaries(PairingData data, private List<CandidateSummaryExcelDto> createCandidateSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount, PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount) { int unusedMemberCount, int abGroupCount) {
long fieldMemberCount = data.getMembers().stream() long fieldMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("FIELD")).count();
.filter(member -> member.getRole().name().equals("FIELD")).count(); long externalMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("EXTERNAL")).count();
long externalMemberCount = data.getMembers().stream()
.filter(member -> member.getRole().name().equals("EXTERNAL")).count();
long womenOnlyCenterCount = data.getCenters().stream().filter(Center::isWomenOnly).count(); long womenOnlyCenterCount = data.getCenters().stream().filter(Center::isWomenOnly).count();
long noCandidateCenterCount = data.getCenters().stream().filter( long noCandidateCenterCount = data.getCenters().stream()
center -> candidates.getAssignmentCandidates().stream() .filter(center -> candidates.getAssignmentCandidates().stream()
.noneMatch(candidate -> candidate.getCenterId().equals(center.getId()))).count(); .noneMatch(candidate -> candidate.getCenterId().equals(center.getId())))
return List.of(new CandidateSummaryExcelDto("전체 위원 수", String.valueOf(data.getMembers().size()), .count();
"입력 위원 수"), return List.of(
new CandidateSummaryExcelDto("전체 위원 수", String.valueOf(data.getMembers().size()), "입력 위원 수"),
new CandidateSummaryExcelDto("현장위원 수", String.valueOf(fieldMemberCount), "현장위원 입력 수"), new CandidateSummaryExcelDto("현장위원 수", String.valueOf(fieldMemberCount), "현장위원 입력 수"),
new CandidateSummaryExcelDto("외부위원 수", String.valueOf(externalMemberCount), "외부위원 입력 수"), new CandidateSummaryExcelDto("외부위원 수", String.valueOf(externalMemberCount), "외부위원 입력 수"),
new CandidateSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size()), "입력 센터 수"), new CandidateSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size()), "입력 센터 수"),
new CandidateSummaryExcelDto("여성 전용 센터 수", String.valueOf(womenOnlyCenterCount), new CandidateSummaryExcelDto("여성 전용 센터 수", String.valueOf(womenOnlyCenterCount), "여성 위원만 가능한 센터 수"),
"여성 위원만 가능한 센터 수"), new CandidateSummaryExcelDto("공휴일 수", new CandidateSummaryExcelDto("공통 불가일 수", String.valueOf(commonUnavailableDates(data).size()), "배정 제외 공통 불가능 일자 수"),
String.valueOf(commonUnavailableDates(data).size()), "배정 제외 공통 불가일자 수"), new CandidateSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size()), "현장+외부 조합 후보 수"),
new CandidateSummaryExcelDto("페어 후보 수", new CandidateSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size()), "페어별 파견 권역 후보 수"),
String.valueOf(candidates.getPairCandidates().size()), "현장+외부 조합 후보 수"), new CandidateSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size()), "solver 입력 배정 후보 수"),
new CandidateSummaryExcelDto("파견 권역 후보 수", new CandidateSummaryExcelDto("후보 없는 센터 수", String.valueOf(noCandidateCenterCount), "배정 후보가 하나도 없는 센터 수"),
String.valueOf(candidates.getDispatchRegionCandidates().size()), "페어별 파견 권역 후보 수"),
new CandidateSummaryExcelDto("배정 후보 수",
String.valueOf(candidates.getAssignmentCandidates().size()), "solver 입력 배정 후보 수"),
new CandidateSummaryExcelDto("후보 없는 센터 수", String.valueOf(noCandidateCenterCount),
"배정 후보가 하나도 없는 센터 수"),
new CandidateSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount), "최종 배정된 센터 수"), new CandidateSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount), "최종 배정된 센터 수"),
new CandidateSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount), new CandidateSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount), "최종 미배정 센터 수"),
"최종 미배정 센터 수"), new CandidateSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount), "최종 배정에 포함되지 않은 위원 수"),
new CandidateSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount),
"최종 배정에 포함되지 않은 위원 수"),
new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수")); new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수"));
} }
@@ -460,11 +528,9 @@ public class PairingSolverService {
Map<String, Center> centerMap = data.getCenters().stream() Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left)); .collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
List<RuleViolationExcelDto> checks = new ArrayList<>(); List<RuleViolationExcelDto> checks = new ArrayList<>();
checks.add(checkDuplicate( checks.add(checkDuplicate(selectedAssignments.stream().map(AssignmentCandidate::getCenterId).toList(), "센터 1회 초과 배정"));
selectedAssignments.stream().map(AssignmentCandidate::getCenterId).toList(),
"한 센터 1회 초과 배정"));
checks.add(checkMaxGroupCount(selectedAssignments, this::pairDayKey, checks.add(checkMaxGroupCount(selectedAssignments, this::pairDayKey,
pairingProperties.getRule().getMaxCentersPerPairPerDay())); pairingProperties.getRule().getMaxCentersPerPairPerDay(), "페어 하루 최대 센터 수"));
checks.add(checkMemberDateDuplicate(selectedAssignments)); checks.add(checkMemberDateDuplicate(selectedAssignments));
checks.add(checkPairDayAdjacentClassification(selectedAssignments)); checks.add(checkPairDayAdjacentClassification(selectedAssignments));
checks.add(checkWomenOnly(selectedAssignments, memberMap, centerMap)); checks.add(checkWomenOnly(selectedAssignments, memberMap, centerMap));
@@ -472,6 +538,8 @@ public class PairingSolverService {
checks.add(checkHistoryCenter(selectedAssignments, memberMap)); checks.add(checkHistoryCenter(selectedAssignments, memberMap));
checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data))); checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data)));
checks.add(checkABDateOverlap(abPairMatches)); checks.add(checkABDateOverlap(abPairMatches));
checks.add(checkAllMembersUsed(data, selectedAssignments));
checks.add(checkMemberVisitBalance(data, selectedAssignments));
return checks; return checks;
} }
@@ -484,52 +552,39 @@ public class PairingSolverService {
} }
private RuleViolationExcelDto checkMaxGroupCount(List<AssignmentCandidate> assignments, private RuleViolationExcelDto checkMaxGroupCount(List<AssignmentCandidate> assignments,
Function<AssignmentCandidate, String> classifier, int max) { Function<AssignmentCandidate, String> classifier, int max, String ruleName) {
Map<String, Long> countsByKey = assignments.stream() Map<String, Long> countsByKey = assignments.stream().collect(Collectors.groupingBy(classifier, Collectors.counting()));
.collect(Collectors.groupingBy(classifier, Collectors.counting()));
List<String> violations = countsByKey.entrySet().stream() List<String> violations = countsByKey.entrySet().stream()
.filter(entry -> entry.getValue() > max) .filter(entry -> entry.getValue() > max)
.map(entry -> { .map(entry -> entry.getKey() + "=" + entry.getValue())
String var10000 = entry.getKey(); .toList();
return var10000 + "=" + entry.getValue(); return new RuleViolationExcelDto(ruleName, violations.isEmpty() ? "PASS" : "FAIL",
}).toList();
return new RuleViolationExcelDto("한 페어 하루 최대 센터 수", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations)); violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
} }
private RuleViolationExcelDto checkMemberDateDuplicate(List<AssignmentCandidate> assignments) { private RuleViolationExcelDto checkMemberDateDuplicate(List<AssignmentCandidate> assignments) {
Map<String, Set<String>> pairKeysByMemberDate = new HashMap<>(); Map<String, Set<String>> pairKeysByMemberDate = new HashMap<>();
assignments.forEach(candidate -> { assignments.forEach(candidate -> {
pairKeysByMemberDate.computeIfAbsent( pairKeysByMemberDate.computeIfAbsent(candidate.getFieldMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
candidate.getFieldMemberId() + "|" + candidate.getDate(), pairKeysByMemberDate.computeIfAbsent(candidate.getExternalMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
key -> new HashSet<>()).add(pairKey(candidate));
pairKeysByMemberDate.computeIfAbsent(
candidate.getExternalMemberId() + "|" + candidate.getDate(),
key -> new HashSet<>()).add(pairKey(candidate));
}); });
List<String> violations = pairKeysByMemberDate.entrySet().stream() List<String> violations = pairKeysByMemberDate.entrySet().stream()
.filter(entry -> (entry.getValue()).size() > 1) .filter(entry -> entry.getValue().size() > 1)
.map(entry -> { .map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
String var10000 = entry.getKey(); .toList();
return var10000 + "=" + String.join("/", entry.getValue());
}).toList();
return new RuleViolationExcelDto("같은 위원 같은 날짜 중복", violations.isEmpty() ? "PASS" : "FAIL", return new RuleViolationExcelDto("같은 위원 같은 날짜 중복", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations)); violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
} }
private RuleViolationExcelDto checkPairDayAdjacentClassification( private RuleViolationExcelDto checkPairDayAdjacentClassification(List<AssignmentCandidate> assignments) {
List<AssignmentCandidate> assignments) { Map<String, Set<String>> adjacentClassificationsByPairDay = assignments.stream()
Map<String, Set<String>> adjacentClassificationsByPairDay = assignments.stream().collect( .collect(Collectors.groupingBy(this::pairDayKey,
Collectors.groupingBy(this::pairDayKey, Collectors.mapping(AssignmentCandidate::getAdjacentRegionClassification, Collectors.toSet())));
Collectors.mapping(AssignmentCandidate::getAdjacentRegionClassification,
Collectors.toSet())));
List<String> violations = adjacentClassificationsByPairDay.entrySet().stream() List<String> violations = adjacentClassificationsByPairDay.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1).map(entry -> { .filter(entry -> entry.getValue().size() > 1)
String var10000 = entry.getKey(); .map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
return var10000 + "=" + String.join("/", entry.getValue()); .toList();
}).toList(); return new RuleViolationExcelDto("페어 하루 1개 인접지역분류", violations.isEmpty() ? "PASS" : "FAIL",
return new RuleViolationExcelDto("한 페어 하루 1개 인접지역 분류", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations)); violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
} }
@@ -537,72 +592,82 @@ public class PairingSolverService {
Map<String, Member> memberMap, Map<String, Center> centerMap) { Map<String, Member> memberMap, Map<String, Center> centerMap) {
List<String> violations = assignments.stream() List<String> violations = assignments.stream()
.filter(candidate -> centerMap.get(candidate.getCenterId()).isWomenOnly()) .filter(candidate -> centerMap.get(candidate.getCenterId()).isWomenOnly())
.filter(candidate -> .filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getGender() != Gender.FEMALE
memberMap.get(candidate.getFieldMemberId()).getGender() != Gender.FEMALE || || memberMap.get(candidate.getExternalMemberId()).getGender() != Gender.FEMALE)
memberMap.get(candidate.getExternalMemberId()).getGender() != Gender.FEMALE .map(AssignmentCandidate::getCenterId)
) .toList();
.map(AssignmentCandidate::getCenterId).toList();
return new RuleViolationExcelDto("여성 전용 센터 조건", violations.isEmpty() ? "PASS" : "FAIL", return new RuleViolationExcelDto("여성 전용 센터 조건", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations)); violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
} }
private RuleViolationExcelDto checkActivityRegion(List<AssignmentCandidate> assignments, private RuleViolationExcelDto checkActivityRegion(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
Map<String, Member> memberMap) { List<String> violations = assignments.stream()
List<String> violations = assignments.stream().filter(candidate -> .filter(candidate -> hasActivityRegion(memberMap.get(candidate.getFieldMemberId()), candidate.getDispatchRegion())
hasActivityRegion(memberMap.get(candidate.getFieldMemberId()), || hasActivityRegion(memberMap.get(candidate.getExternalMemberId()), candidate.getDispatchRegion()))
candidate.getDispatchRegion()) .map(candidate -> candidate.getCenterId() + ":" + candidate.getDispatchRegion())
|| hasActivityRegion(memberMap.get(candidate.getExternalMemberId()), .toList();
candidate.getDispatchRegion()))
.map(candidate -> {
String var10000 = candidate.getCenterId();
return var10000 + ":" + candidate.getDispatchRegion();
}).toList();
return new RuleViolationExcelDto("활동지역 상피제", violations.isEmpty() ? "PASS" : "FAIL", return new RuleViolationExcelDto("활동지역 상피제", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations)); violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
} }
private boolean hasActivityRegion(Member member, String dispatchRegion) { private boolean hasActivityRegion(Member member, String dispatchRegion) {
return java.util.Arrays.stream(member.getActivityRegion().split(",")) return java.util.Arrays.stream(member.getActivityRegion().split(",")).map(String::trim).anyMatch(dispatchRegion::equals);
.map(String::trim)
.anyMatch(dispatchRegion::equals);
} }
private RuleViolationExcelDto checkHistoryCenter(List<AssignmentCandidate> assignments, private RuleViolationExcelDto checkHistoryCenter(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
Map<String, Member> memberMap) { List<String> violations = assignments.stream()
List<String> violations = assignments.stream().filter(candidate -> .filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getHistoryCenterIds().contains(candidate.getCenterId())
memberMap.get(candidate.getFieldMemberId()) || memberMap.get(candidate.getExternalMemberId()).getHistoryCenterIds().contains(candidate.getCenterId()))
.getHistoryCenterIds() .map(AssignmentCandidate::getCenterId)
.contains(candidate.getCenterId()) || .toList();
memberMap.get(candidate.getExternalMemberId())
.getHistoryCenterIds()
.contains(candidate.getCenterId())
)
.map(AssignmentCandidate::getCenterId).toList();
return new RuleViolationExcelDto("2023년 진행 센터 재배정", violations.isEmpty() ? "PASS" : "FAIL", return new RuleViolationExcelDto("2023년 진행 센터 재배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations)); violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
} }
private RuleViolationExcelDto checkHoliday(List<AssignmentCandidate> assignments, private RuleViolationExcelDto checkHoliday(List<AssignmentCandidate> assignments, Set<LocalDate> holidays) {
Set<LocalDate> holidays) {
List<String> violations = assignments.stream() List<String> violations = assignments.stream()
.filter(candidate -> holidays.contains(candidate.getDate())) .filter(candidate -> holidays.contains(candidate.getDate()))
.map(candidate -> { .map(candidate -> candidate.getCenterId() + ":" + candidate.getDate())
String var10000 = candidate.getCenterId(); .toList();
return var10000 + ":" + candidate.getDate();
}).toList();
return new RuleViolationExcelDto("공휴일 배정", violations.isEmpty() ? "PASS" : "FAIL", return new RuleViolationExcelDto("공휴일 배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations)); violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
} }
private RuleViolationExcelDto checkABDateOverlap(Map<String, ABPairMatch> abPairMatches) { private RuleViolationExcelDto checkABDateOverlap(Map<String, ABPairMatch> abPairMatches) {
return new RuleViolationExcelDto("A/B 페어 날짜 겹침", "PASS", return new RuleViolationExcelDto("A/B 페어 날짜 겹침", "PASS", "A/B 그룹은 날짜가 겹치지 않는 페어만 후처리로 생성합니다.");
"A/B 그룹은 날짜가 겹치지 않는 페어끼리만 후처리로 생성됩니다."); }
private RuleViolationExcelDto checkAllMembersUsed(PairingData data,
List<AssignmentCandidate> assignments) {
Set<String> usedMemberIds = assignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.collect(Collectors.toSet());
List<String> unusedMemberIds = data.getMembers().stream()
.map(Member::getId)
.filter(memberId -> !usedMemberIds.contains(memberId))
.toList();
return new RuleViolationExcelDto("위원 전원 조편성", unusedMemberIds.isEmpty() ? "PASS" : "FAIL",
unusedMemberIds.isEmpty() ? "위반 없음" : String.join(", ", unusedMemberIds));
}
private RuleViolationExcelDto checkMemberVisitBalance(PairingData data,
List<AssignmentCandidate> assignments) {
Map<String, Long> visitCounts = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, member -> 0L, (left, right) -> left));
assignments.forEach(candidate -> {
visitCounts.merge(candidate.getFieldMemberId(), 1L, Long::sum);
visitCounts.merge(candidate.getExternalMemberId(), 1L, Long::sum);
});
long min = visitCounts.values().stream().mapToLong(Long::longValue).min().orElse(0L);
long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L);
double average = visitCounts.values().stream().mapToLong(Long::longValue).average().orElse(0.0D);
String detail = "min=" + min + ", max=" + max + ", avg=" + String.format("%.2f", average);
return new RuleViolationExcelDto("위원별 방문 센터 수 균등 배분", "PASS", detail);
} }
private String formatDates(Set<LocalDate> dates) { private String formatDates(Set<LocalDate> dates) {
return (String) dates.stream().sorted().map(LocalDate::toString) return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", "));
.collect(Collectors.joining(", "));
} }
private Set<LocalDate> commonUnavailableDates(PairingData data) { private Set<LocalDate> commonUnavailableDates(PairingData data) {
@@ -612,59 +677,53 @@ public class PairingSolverService {
private Map<String, List<Integer>> groupIndexes(List<AssignmentCandidate> candidates, private Map<String, List<Integer>> groupIndexes(List<AssignmentCandidate> candidates,
Function<AssignmentCandidate, String> classifier) { Function<AssignmentCandidate, String> classifier) {
Map<String, List<Integer>> grouped = new HashMap<>(); Map<String, List<Integer>> grouped = new HashMap<>();
for (int i = 0; i < candidates.size(); i++) {
for (int i = 0; i < candidates.size(); ++i) { grouped.computeIfAbsent(classifier.apply(candidates.get(i)), key -> new ArrayList<>()).add(i);
(grouped.computeIfAbsent(
classifier.apply(candidates.get(i)),
key -> new ArrayList<>())).add(i);
} }
return grouped; return grouped;
} }
private BoolVar[] toLiteralArray(List<Integer> indexes, BoolVar[] assignmentVars) { private BoolVar[] toLiteralArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index]) return indexes.stream().map(index -> assignmentVars[index]).toArray(BoolVar[]::new);
.toArray(BoolVar[]::new);
} }
private LinearArgument[] toLinearArgumentArray(List<Integer> indexes, BoolVar[] assignmentVars) { private LinearArgument[] toLinearArgumentArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index]) return indexes.stream().map(index -> assignmentVars[index]).toArray(LinearArgument[]::new);
.toArray(LinearArgument[]::new);
} }
private String pairKey(AssignmentCandidate candidate) { private String pairKey(AssignmentCandidate candidate) {
String var10000 = candidate.getFieldMemberId(); return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId();
return var10000 + "|" + candidate.getExternalMemberId(); }
private String counterpartId(String pairKey, String memberId) {
String[] memberIds = pairKey.split("\\|", 2);
if (memberIds.length != 2) {
return "";
}
return memberId.equals(memberIds[0]) ? memberIds[1] : memberIds[0];
} }
private String pairDayKey(AssignmentCandidate candidate) { private String pairDayKey(AssignmentCandidate candidate) {
String var10000 = pairKey(candidate); return pairKey(candidate) + "|" + candidate.getDate();
return var10000 + "|" + candidate.getDate();
} }
private String pairDayAdjacentKey(AssignmentCandidate candidate) { private String pairDayAdjacentKey(AssignmentCandidate candidate) {
String var10000 = pairDayKey(candidate); return pairDayKey(candidate) + "|" + candidate.getAdjacentRegionClassification();
return var10000 + "|" + candidate.getAdjacentRegionClassification();
} }
static { public record SolveSelection(boolean hasSolution, List<AssignmentCandidate> selectedAssignments, String status) {
Loader.loadNativeLibraries();
} }
private static record ABPairBuildResult(Map<String, ABPairMatch> matches, private record ABPairBuildResult(Map<String, ABPairMatch> matches, List<ABPairExcelDto> rows) {
List<ABPairExcelDto> rows) {
} }
private static record UsedPair(String pairKey, String fieldMemberId, String externalMemberId, private record UsedPair(String pairKey, String fieldMemberId, String externalMemberId,
Set<LocalDate> dates, Set<String> dispatchRegions) { Set<LocalDate> dates, Set<String> dispatchRegions) {
private static UsedPair of(String pairKey, List<AssignmentCandidate> assignments) { private static UsedPair of(String pairKey, List<AssignmentCandidate> assignments) {
AssignmentCandidate first = assignments.get(0); AssignmentCandidate first = assignments.get(0);
return new UsedPair(pairKey, first.getFieldMemberId(), first.getExternalMemberId(), return new UsedPair(pairKey, first.getFieldMemberId(), first.getExternalMemberId(),
assignments.stream().map(AssignmentCandidate::getDate).collect(Collectors.toSet()), assignments.stream().map(AssignmentCandidate::getDate).collect(Collectors.toSet()),
assignments.stream().map(AssignmentCandidate::getDispatchRegion) assignments.stream().map(AssignmentCandidate::getDispatchRegion).collect(Collectors.toSet()));
.collect(Collectors.toSet()));
} }
private boolean canBeABWith(UsedPair other) { private boolean canBeABWith(UsedPair other) {
@@ -676,4 +735,8 @@ public class PairingSolverService {
&& !Objects.equals(externalMemberId, other.externalMemberId); && !Objects.equals(externalMemberId, other.externalMemberId);
} }
} }
static {
Loader.loadNativeLibraries();
}
} }

View File

@@ -69,22 +69,29 @@ pairing:
ignored-rank: 99 ignored-rank: 99
objective: objective:
# 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다. # 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다.
assignment-weight: 1000000 assignment-weight: 1_000_000
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다. # 최종 배정에 위원 1명이 새로 포함될 때 부여하는 점수입니다. 값이 클수록 미사용 위원을 줄이는 방향으로 탐색합니다.
preference-base-weight: 1000 used-member-weight: 300_000
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다. # 이미 많이 배정된 위원이 추가 배정될 때 차감하는 점수입니다. 값이 클수록 위원별 방문 센터 수를 평균에 가깝게 분산합니다.
preference-rank-penalty: 10 member-balance-weight: 100_000
# 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다. # 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다.
residence-match-weight: 10000 residence-match-weight: 30_000
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다.
preference-base-weight: 1_000
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다.
preference-rank-penalty: 100
candidate: candidate:
# 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다. # 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다.
max-dispatch-regions-per-pair: 8 max-dispatch-regions-per-pair: 20
# 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다. # 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다.
max-assignments-per-center: 100 max-assignments-per-center: 100
# 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다. # 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다.
max-assignments-per-member: 160 max-assignments-per-member: 160
# 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 값이 클수록 전원 조편성 가능성은 커지지만 solver 후보 수가 늘어납니다.
max-dates-per-assignment-candidate: 5
solver: solver:
# OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다. # OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다.
max-time-seconds: 60.0 max-time-seconds: 120.0
# OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다. # OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다.
num-search-workers: 15 num-search-workers: 15

View File

@@ -22,10 +22,10 @@ class PairingCandidateServiceTest {
private final PairingCandidateService service = new PairingCandidateService(PairingTestSupport.pairingProperties()); private final PairingCandidateService service = new PairingCandidateService(PairingTestSupport.pairingProperties());
@Test @Test
void generateExcludesNewNewPair() { void generateAllowsNewNewPairBecauseAllMembersMustBePaired() {
PairingCandidates candidates = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.NEW, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.NEW, "03", Set.of()), center("center", false))); PairingCandidates candidates = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.NEW, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.NEW, "03", Set.of()), center("center", false)));
Assertions.assertThat(candidates.getPairCandidates()).isEmpty(); Assertions.assertThat(candidates.getPairCandidates()).hasSize(1);
Assertions.assertThat(candidates.getAssignmentCandidates()).isEmpty(); Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(3);
} }
@Test @Test
@@ -49,7 +49,7 @@ class PairingCandidateServiceTest {
PairingCandidates maleIncluded = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.MALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true))); PairingCandidates maleIncluded = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.MALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true)));
PairingCandidates femaleOnly = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true))); PairingCandidates femaleOnly = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true)));
Assertions.assertThat(maleIncluded.getAssignmentCandidates()).isEmpty(); Assertions.assertThat(maleIncluded.getAssignmentCandidates()).isEmpty();
Assertions.assertThat(femaleOnly.getAssignmentCandidates()).hasSize(1); Assertions.assertThat(femaleOnly.getAssignmentCandidates()).hasSize(3);
} }
@Test @Test
@@ -63,7 +63,7 @@ class PairingCandidateServiceTest {
PairingData data = PairingData.builder().members(List.of(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()))).municipalities(List.of(Municipality.builder().id("municipality").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).build())).centers(List.of(center("center", false))).memberRegionCodes(List.of()).centerAdjacentRegions(List.of(CenterAdjacentRegion.builder().dispatchRegion("01").adjacentRegionClassification("A").build())).preferenceMatchRules(List.of(PreferenceMatchRule.builder().priority(1).fieldMemberPreferenceRank(1).externalMemberPreferenceRank(99).build())).commonUnavailableDates(Set.of()).build(); PairingData data = PairingData.builder().members(List.of(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()))).municipalities(List.of(Municipality.builder().id("municipality").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).build())).centers(List.of(center("center", false))).memberRegionCodes(List.of()).centerAdjacentRegions(List.of(CenterAdjacentRegion.builder().dispatchRegion("01").adjacentRegionClassification("A").build())).preferenceMatchRules(List.of(PreferenceMatchRule.builder().priority(1).fieldMemberPreferenceRank(1).externalMemberPreferenceRank(99).build())).commonUnavailableDates(Set.of()).build();
PairingCandidates candidates = service.generate(data); PairingCandidates candidates = service.generate(data);
Assertions.assertThat(candidates.getDispatchRegionCandidates()).hasSize(1); Assertions.assertThat(candidates.getDispatchRegionCandidates()).hasSize(1);
Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(1); Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(3);
} }
@Test @Test

View File

@@ -33,8 +33,10 @@ class PairingServiceTest {
new PairingNormalizeService(PairingTestSupport.pairingProperties()), new PairingNormalizeService(PairingTestSupport.pairingProperties()),
new PairingHolidayService(new DatagoHolidayCache(new StubDatagoExtentionApiClient())), new PairingHolidayService(new DatagoHolidayCache(new StubDatagoExtentionApiClient())),
new PairingValidationService(PairingTestSupport.pairingProperties()), new PairingValidationService(PairingTestSupport.pairingProperties()),
new PairingCandidateService(PairingTestSupport.pairingProperties()), new PairingScheduleService(
new PairingSolverService(PairingTestSupport.pairingProperties()) new PairingCandidateService(PairingTestSupport.pairingProperties()),
new PairingSolverService(PairingTestSupport.pairingProperties()),
PairingTestSupport.pairingProperties())
); );
@Test @Test
@@ -61,8 +63,12 @@ class PairingServiceTest {
List<RuleViolationExcelDto> ruleChecks = ExcelMapper.readFromWorkbook(workbook, List<RuleViolationExcelDto> ruleChecks = ExcelMapper.readFromWorkbook(workbook,
RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1); RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1);
Assertions.assertThat(ruleChecks) Assertions.assertThat(ruleChecks)
.filteredOn(ruleCheck -> !"위원 전원 조편성".equals(ruleCheck.getRuleName()))
.extracting(RuleViolationExcelDto::getResult) .extracting(RuleViolationExcelDto::getResult)
.doesNotContain("FAIL"); .doesNotContain("FAIL");
Assertions.assertThat(ruleChecks)
.extracting(RuleViolationExcelDto::getRuleName)
.contains("위원 전원 조편성", "위원별 방문 센터 수 균등 배분");
} }
} }
} }

View File

@@ -58,6 +58,22 @@ class PairingSolverServiceTest {
Assertions.assertThat(counterpartCounts).hasSize(2); Assertions.assertThat(counterpartCounts).hasSize(2);
} }
@Test
void selectAppliesExistingCounterpartsToBuddyLimit() {
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external1").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external2").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external3").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external1", "c1", "A", LocalDate.of(2026, 5, 1)), assignment("field", "external2", "c2", "A", LocalDate.of(2026, 5, 2)), assignment("field", "external3", "c3", "A", LocalDate.of(2026, 5, 3)))).build();
PairingSolverService.SolveSelection selection = service.select(candidates,
Map.of("field", Set.of("external1"), "external1", Set.of("field")));
Assertions.assertThat(selection.selectedAssignments()).hasSize(2);
Assertions.assertThat(selection.selectedAssignments())
.extracting(AssignmentCandidate::getExternalMemberId)
.contains("external1");
Assertions.assertThat(selection.selectedAssignments())
.extracting(AssignmentCandidate::getExternalMemberId)
.containsAnyOf("external2", "external3");
}
@Test @Test
void solveAddsABGroupForSimilarPairsWithoutOverlappingDates() { void solveAddsABGroupForSimilarPairsWithoutOverlappingDates() {
PairingData data = dataWithMembersAndCenters(List.of(member("field1", MemberRole.FIELD), member("external1", MemberRole.EXTERNAL), member("field2", MemberRole.FIELD), member("external2", MemberRole.EXTERNAL)), List.of(center("c1"), center("c2"))); PairingData data = dataWithMembersAndCenters(List.of(member("field1", MemberRole.FIELD), member("external1", MemberRole.EXTERNAL), member("field2", MemberRole.FIELD), member("external2", MemberRole.EXTERNAL)), List.of(center("c1"), center("c2")));