## 1 Introduction  
As the demand and scale of application software continue to increase, automated testing has become the mainstream trend in software testing. Software testing is the process of evaluating software applications to determine whether there are any defects, ensuring the quality of the software product. However, software testing is generally a time-consuming and labor-intensive process, accounting for 50% of the software development cost [1]. The automatic generation of test cases is a crucial aspect of software-testing automation. The traditional manual method of generating test cases often results in a limited number of them, which is not only costly but also requires highly skilled and experienced testing personnel to ensure code coverage. This leads to the fact that manual test case generation methods often adversely affect the progress of software testing during the rapid iteration process of software development. Therefore, they are gradually being replaced by automated test case generation [2]. Indeed, due to the diversity of the programs to be tested and the uncertainty surrounding test cases, efficiently generating a high-coverage and concise test case set has become a challenging technical task. The traditional techniques for generating test cases, primarily based on random generation or the conversion of software structures into symbolic calculations, are gradually no longer applicable to the automatic generation of test cases for large and complex software. Because test case generation is an undecidable problem, many search algorithms have inherent flaws and weaknesses. Test case generation aims to produce a finite and optimal set of test cases, where \"optimal\" means a minimum set of cases that can suggest as many errors as possible according to the test adequacy criteria Test adequacy criteria are used to determine the quality of the test cases and whether the testing process is complete [3]. The cause-effect graph method is a method that can be used to design test cases for software by analyzing various combinations of inputs based on a graphical method, which is suitable for examining the outputs of the software under various combinations of program input conditions. Because a cause-effect graph is a graphical representation of Boolean expressions, it can be easily converted between them, and the cause-effect graph provides more intuitive access to information. In the cause-effect graph approach, firstly, by looking at the cause-effect graph, we can know the condition (cause), the operation (effect), and the relationship between them, and then we are able to derive the truth table corresponding to the cause and effect. One of the main challenges in using cause-effect graphs for software testing is how to reduce the size of the set of generated test cases while maintaining the quality of the tests. Several approaches have been proposed to solve this problem [4; 5; 6], but there are still some difficulties: the methods are complex, and redundancy can lead to the generation of unnecessary test cases. However, it is impractical to always test all possible use cases exhaustively because the size of the input space grows exponentially as the number of input variables increases. Therefore, approaches based on combinatorial testing are often used to generate test cases. Such methods find faults by detecting all combinations of values taken in the software system factors. The software's own factors and the interactions among them can trigger faults. As technology continues to evolve and the software complexity continues to increase, the combinatorial space of software factors becomes exceptionally large, making it difficult to provide comprehensive coverage of the combined test cases. Therefore, the efficient way to select and generate test cases with small sizes and high error detection rates is a critical task in the field of combinatorial testing. Generating the smallest set of combinatorial test cases is an NP-complete problem [7].